1 /*
2 * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "softbus_proxychannel_manager.h"
16
17 #include <securec.h>
18 #include <string.h>
19
20 #include "access_control.h"
21 #include "auth_interface.h"
22 #include "auth_manager.h"
23 #include "auth_session_fsm.h"
24 #include "bus_center_event.h"
25 #include "bus_center_info_key.h"
26 #include "bus_center_manager.h"
27 #include "common_list.h"
28 #include "data_bus_native.h"
29 #include "lnn_distributed_net_ledger.h"
30 #include "softbus_adapter_crypto.h"
31 #include "softbus_adapter_hitrace.h"
32 #include "softbus_adapter_mem.h"
33 #include "softbus_adapter_thread.h"
34 #include "softbus_conn_interface.h"
35 #include "softbus_def.h"
36 #include "softbus_feature_config.h"
37 #include "softbus_hisysevt_transreporter.h"
38 #include "softbus_proxychannel_callback.h"
39 #include "softbus_proxychannel_control.h"
40 #include "softbus_proxychannel_listener.h"
41 #include "softbus_proxychannel_message.h"
42 #include "softbus_proxychannel_session.h"
43 #include "softbus_proxychannel_transceiver.h"
44 #include "softbus_utils.h"
45 #include "trans_auth_negotiation.h"
46 #include "trans_channel_limit.h"
47 #include "trans_channel_manager.h"
48 #include "trans_event.h"
49 #include "trans_log.h"
50 #include "trans_session_manager.h"
51
52 #define ID_OFFSET (1)
53
54 #define PROXY_CHANNEL_CONTROL_TIMEOUT 19 // 19s
55 #define PROXY_CHANNEL_BT_IDLE_TIMEOUT 240 // 4min
56 #define PROXY_CHANNEL_IDLE_TIMEOUT 15 // 10800 = 3 hour
57 #define PROXY_CHANNEL_TCP_IDLE_TIMEOUT 43200 // tcp 24 hour
58 #define PROXY_CHANNEL_CLIENT 0
59 #define PROXY_CHANNEL_SERVER 1
60 static SoftBusList *g_proxyChannelList = NULL;
61
62 typedef struct {
63 int32_t channelType;
64 int32_t businessType;
65 ConfigType configType;
66 } ConfigTypeMap;
67
GetProxyChannelMgrHead(void)68 SoftBusList *GetProxyChannelMgrHead(void)
69 {
70 return g_proxyChannelList;
71 }
72
GetProxyChannelLock(void)73 int32_t GetProxyChannelLock(void)
74 {
75 if (g_proxyChannelList == NULL) {
76 return SOFTBUS_NO_INIT;
77 }
78 if (SoftBusMutexLock(&g_proxyChannelList->lock) != SOFTBUS_OK) {
79 TRANS_LOGE(TRANS_CTRL, "lock failed");
80 return SOFTBUS_LOCK_ERR;
81 }
82 return SOFTBUS_OK;
83 }
84
ReleaseProxyChannelLock(void)85 void ReleaseProxyChannelLock(void)
86 {
87 if (g_proxyChannelList == NULL) {
88 return;
89 }
90 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
91 }
92
ChanIsEqual(ProxyChannelInfo * a,ProxyChannelInfo * b)93 static bool ChanIsEqual(ProxyChannelInfo *a, ProxyChannelInfo *b)
94 {
95 if ((a->myId == b->myId) &&
96 (a->peerId == b->peerId) &&
97 (strncmp(a->identity, b->identity, sizeof(a->identity)) == 0)) {
98 return true;
99 }
100 return false;
101 }
102
ResetChanIsEqual(int8_t status,ProxyChannelInfo * a,ProxyChannelInfo * b)103 static bool ResetChanIsEqual(int8_t status, ProxyChannelInfo *a, ProxyChannelInfo *b)
104 {
105 if (status == PROXY_CHANNEL_STATUS_HANDSHAKEING) {
106 if ((a->myId == b->myId) &&
107 (strncmp(a->identity, b->identity, sizeof(a->identity)) == 0)) {
108 return true;
109 }
110 }
111
112 if ((a->myId == b->myId) &&
113 (a->peerId == b->peerId) &&
114 (strncmp(a->identity, b->identity, sizeof(a->identity)) == 0)) {
115 return true;
116 }
117 return false;
118 }
119
TransProxyGetAppInfoType(int16_t myId,const char * identity,AppType * appType)120 int32_t TransProxyGetAppInfoType(int16_t myId, const char *identity, AppType *appType)
121 {
122 TRANS_CHECK_AND_RETURN_RET_LOGE(
123 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "fail to lock mutex!");
124 ProxyChannelInfo *item = NULL;
125 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
126 if ((item->myId == myId) && (strcmp(item->identity, identity) == 0)) {
127 *appType = item->appInfo.appType;
128 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
129 return SOFTBUS_OK;
130 }
131 }
132 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
133 return SOFTBUS_TRANS_PROXY_ERROR_APP_TYPE;
134 }
135
TransProxyUpdateAckInfo(ProxyChannelInfo * info)136 static int32_t TransProxyUpdateAckInfo(ProxyChannelInfo *info)
137 {
138 TRANS_CHECK_AND_RETURN_RET_LOGE((g_proxyChannelList != NULL && info != NULL), SOFTBUS_INVALID_PARAM, TRANS_CTRL,
139 "g_proxyChannelList or item is null");
140 TRANS_CHECK_AND_RETURN_RET_LOGE(
141 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
142 ProxyChannelInfo *item = NULL;
143 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
144 if ((item->myId == info->myId) && (strncmp(item->identity, info->identity, sizeof(item->identity)) == 0)) {
145 item->peerId = info->peerId;
146 item->status = PROXY_CHANNEL_STATUS_COMPLETED;
147 item->timeout = 0;
148 item->appInfo.encrypt = info->appInfo.encrypt;
149 item->appInfo.algorithm = info->appInfo.algorithm;
150 item->appInfo.crc = info->appInfo.crc;
151 item->appInfo.myData.dataConfig = info->appInfo.myData.dataConfig;
152 item->appInfo.peerHandleId = info->appInfo.peerHandleId;
153 if (memcpy_s(&(item->appInfo.peerData), sizeof(item->appInfo.peerData),
154 &(info->appInfo.peerData), sizeof(info->appInfo.peerData)) != EOK ||
155 memcpy_s(info, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo)) != EOK) {
156 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
157 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
158 return SOFTBUS_MEM_ERR;
159 }
160 SoftbusHitraceStart(SOFTBUS_HITRACE_ID_VALID, (uint64_t)(item->channelId + ID_OFFSET));
161 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
162 return SOFTBUS_OK;
163 }
164 }
165 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
166 return SOFTBUS_TRANS_NODE_NOT_FOUND;
167 }
168
TransRefreshProxyTimesNative(int32_t channelId)169 int32_t TransRefreshProxyTimesNative(int32_t channelId)
170 {
171 TRANS_CHECK_AND_RETURN_RET_LOGE(
172 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
173 TRANS_CHECK_AND_RETURN_RET_LOGE(
174 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
175
176 ProxyChannelInfo *item = NULL;
177 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
178 if (item->myId == channelId) {
179 item->timeout = 0;
180 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
181 return SOFTBUS_OK;
182 }
183 }
184 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
185 return SOFTBUS_TRANS_NODE_NOT_FOUND;
186 }
187
TransProxyAddChanItem(ProxyChannelInfo * chan)188 static int32_t TransProxyAddChanItem(ProxyChannelInfo *chan)
189 {
190 TRANS_CHECK_AND_RETURN_RET_LOGE((g_proxyChannelList != NULL && chan != NULL), SOFTBUS_INVALID_PARAM, TRANS_CTRL,
191 "trans proxy add channel param nullptr!");
192 TRANS_CHECK_AND_RETURN_RET_LOGE(
193 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
194
195 ListAdd(&(g_proxyChannelList->list), &(chan->node));
196 g_proxyChannelList->cnt++;
197 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
198 return SOFTBUS_OK;
199 }
200
TransProxySpecialUpdateChanInfo(ProxyChannelInfo * channelInfo)201 int32_t TransProxySpecialUpdateChanInfo(ProxyChannelInfo *channelInfo)
202 {
203 TRANS_CHECK_AND_RETURN_RET_LOGE((g_proxyChannelList != NULL && channelInfo != NULL), SOFTBUS_INVALID_PARAM,
204 TRANS_CTRL, "g_proxyChannelList or channelInfo is NULL!");
205 TRANS_CHECK_AND_RETURN_RET_LOGE(
206 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
207
208 ProxyChannelInfo *item = NULL;
209 ProxyChannelInfo *nextNode = NULL;
210 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
211 if (item->channelId == channelInfo->channelId) {
212 if (channelInfo->reqId != -1) {
213 item->reqId = channelInfo->reqId;
214 }
215 if (channelInfo->isServer != -1) {
216 item->isServer = channelInfo->isServer;
217 }
218 if (channelInfo->type != CONNECT_TYPE_MAX) {
219 item->type = channelInfo->type;
220 }
221 if (channelInfo->status != -1) {
222 item->status = channelInfo->status;
223 }
224 if (channelInfo->status == PROXY_CHANNEL_STATUS_HANDSHAKEING) {
225 item->connId = channelInfo->connId;
226 }
227 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
228 return SOFTBUS_OK;
229 }
230 }
231 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
232 return SOFTBUS_TRANS_NODE_NOT_FOUND;
233 }
234
TransProxyGetChanByChanId(int32_t chanId,ProxyChannelInfo * chan)235 int32_t TransProxyGetChanByChanId(int32_t chanId, ProxyChannelInfo *chan)
236 {
237 TRANS_CHECK_AND_RETURN_RET_LOGE((g_proxyChannelList != NULL && chan != NULL), SOFTBUS_INVALID_PARAM, TRANS_CTRL,
238 "trans proxy get channel param nullptr!");
239 TRANS_CHECK_AND_RETURN_RET_LOGE(
240 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
241
242 ProxyChannelInfo *item = NULL;
243 ProxyChannelInfo *nextNode = NULL;
244
245 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
246 if (item->channelId == chanId) {
247 if (memcpy_s(chan, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo)) != EOK) {
248 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
249 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
250 return SOFTBUS_MEM_ERR;
251 }
252 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
253 return SOFTBUS_OK;
254 }
255 }
256 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
257 TRANS_LOGE(TRANS_CTRL, "proxy channel not found by chanId. chanId=%{public}d", chanId);
258 return SOFTBUS_TRANS_NODE_NOT_FOUND;
259 }
260
TransProxyGetChanByReqId(int32_t reqId,ProxyChannelInfo * chan)261 int32_t TransProxyGetChanByReqId(int32_t reqId, ProxyChannelInfo *chan)
262 {
263 ProxyChannelInfo *item = NULL;
264 TRANS_CHECK_AND_RETURN_RET_LOGE(
265 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
266 TRANS_CHECK_AND_RETURN_RET_LOGE(
267 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
268
269 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
270 if (item->reqId == reqId && item->status == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
271 *chan = *item;
272 break;
273 }
274 }
275 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
276 return SOFTBUS_OK;
277 }
278
TransProxyDelChanByReqId(int32_t reqId,int32_t errCode)279 void TransProxyDelChanByReqId(int32_t reqId, int32_t errCode)
280 {
281 ProxyChannelInfo *item = NULL;
282 ProxyChannelInfo *nextNode = NULL;
283
284 TRANS_CHECK_AND_RETURN_LOGE(
285 g_proxyChannelList != NULL, TRANS_CTRL, "g_proxyChannelList is null");
286 TRANS_CHECK_AND_RETURN_LOGE(
287 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, TRANS_CTRL, "lock mutex fail!");
288
289 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
290 if ((item->reqId == reqId) &&
291 (item->status == PROXY_CHANNEL_STATUS_PYH_CONNECTING)) {
292 ReleaseProxyChannelId(item->channelId);
293 ListDelete(&(item->node));
294 g_proxyChannelList->cnt--;
295 TRANS_LOGI(TRANS_CTRL, "del channelId by reqId. channelId=%{public}d", item->channelId);
296 SoftBusFree((void *)item->appInfo.fastTransData);
297 item->appInfo.fastTransData = NULL;
298 TransProxyPostOpenFailMsgToLoop(item, errCode);
299 }
300 }
301 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
302 return;
303 }
304
TransProxyDelChanByChanId(int32_t chanlId)305 void TransProxyDelChanByChanId(int32_t chanlId)
306 {
307 ProxyChannelInfo *item = NULL;
308 ProxyChannelInfo *nextNode = NULL;
309
310 TRANS_CHECK_AND_RETURN_LOGE(
311 g_proxyChannelList != NULL, TRANS_CTRL, "g_proxyChannelList is null");
312 TRANS_CHECK_AND_RETURN_LOGE(
313 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, TRANS_CTRL, "lock mutex fail!");
314
315 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
316 if (item->channelId == chanlId) {
317 ReleaseProxyChannelId(item->channelId);
318 ListDelete(&(item->node));
319 if (item->appInfo.fastTransData != NULL) {
320 SoftBusFree((void *)item->appInfo.fastTransData);
321 }
322 (void)memset_s(item->appInfo.sessionKey, sizeof(item->appInfo.sessionKey), 0,
323 sizeof(item->appInfo.sessionKey));
324 SoftBusFree(item);
325 g_proxyChannelList->cnt--;
326 break;
327 }
328 }
329 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
330 TRANS_LOGE(TRANS_CTRL, "del channelId by chanId! channelId=%{public}d", chanlId);
331 return;
332 }
333
TransProxyChanProcessByReqId(int32_t reqId,uint32_t connId)334 void TransProxyChanProcessByReqId(int32_t reqId, uint32_t connId)
335 {
336 ProxyChannelInfo *item = NULL;
337 TRANS_CHECK_AND_RETURN_LOGE(
338 g_proxyChannelList != NULL, TRANS_CTRL, "g_proxyChannelList is null");
339 TRANS_CHECK_AND_RETURN_LOGE(
340 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, TRANS_CTRL, "lock mutex fail!");
341
342 bool isUsing = false;
343 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
344 if (item->reqId == reqId && item->status == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
345 item->status = PROXY_CHANNEL_STATUS_HANDSHAKEING;
346 item->connId = connId;
347 isUsing = true;
348 TransAddConnRefByConnId(connId, (bool)item->isServer);
349 TransProxyPostHandshakeMsgToLoop(item->channelId);
350 }
351 }
352
353 if (!isUsing) {
354 TRANS_LOGW(TRANS_CTRL, "logical channel is already closed, connId=%{public}u", connId);
355 TransProxyCloseConnChannel(connId, false);
356 }
357 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
358 }
359
TransProxyCloseProxyOtherRes(int32_t channelId,const ProxyChannelInfo * info)360 static void TransProxyCloseProxyOtherRes(int32_t channelId, const ProxyChannelInfo *info)
361 {
362 uint32_t connId = info->connId;
363 bool isServer = (bool)info->isServer;
364 ProxyChannelInfo *disChanInfo = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
365 if (disChanInfo != NULL) {
366 if (memcpy_s(disChanInfo, sizeof(ProxyChannelInfo), info, sizeof(ProxyChannelInfo)) != EOK) {
367 SoftBusFree(disChanInfo);
368 SoftBusFree((void *)info);
369 TRANS_LOGE(TRANS_SVC, "memcpy info to disChanInfo failed");
370 return;
371 }
372 }
373 TransProxyPostResetPeerMsgToLoop(info);
374 TransProxyPostDisConnectMsgToLoop(connId, isServer, disChanInfo);
375 }
376
TransProxyReleaseChannelList(ListNode * proxyChannelList,int32_t errCode)377 static void TransProxyReleaseChannelList(ListNode *proxyChannelList, int32_t errCode)
378 {
379 TRANS_LOGI(TRANS_CTRL, "enter.");
380 TRANS_CHECK_AND_RETURN_LOGE((g_proxyChannelList != NULL && !IsListEmpty(proxyChannelList)), TRANS_CTRL,
381 "g_proxyChannelList is null or empty");
382 ProxyChannelInfo *removeNode = NULL;
383 ProxyChannelInfo *nextNode = NULL;
384 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, proxyChannelList, ProxyChannelInfo, node) {
385 ListDelete(&(removeNode->node));
386 if (removeNode->status == PROXY_CHANNEL_STATUS_HANDSHAKEING ||
387 removeNode->status == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
388 TransProxyOpenProxyChannelFail(removeNode->channelId, &(removeNode->appInfo), errCode);
389 } else {
390 OnProxyChannelClosed(removeNode->channelId, &(removeNode->appInfo));
391 }
392 if (removeNode->appInfo.fastTransData != NULL) {
393 SoftBusFree((void *)removeNode->appInfo.fastTransData);
394 }
395 SoftBusFree(removeNode);
396 }
397 }
398
TransProxyDelByConnId(uint32_t connId)399 void TransProxyDelByConnId(uint32_t connId)
400 {
401 ProxyChannelInfo *removeNode = NULL;
402 ProxyChannelInfo *nextNode = NULL;
403 ListNode proxyChannelList;
404
405 TRANS_CHECK_AND_RETURN_LOGE(
406 g_proxyChannelList != NULL, TRANS_CTRL, "g_proxyChannelList is null");
407 TRANS_CHECK_AND_RETURN_LOGE(
408 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, TRANS_CTRL, "lock mutex fail!");
409
410 ListInit(&proxyChannelList);
411 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
412 if (removeNode->connId == connId) {
413 ReleaseProxyChannelId(removeNode->channelId);
414 ListDelete(&(removeNode->node));
415 g_proxyChannelList->cnt--;
416 ListAdd(&proxyChannelList, &removeNode->node);
417 TRANS_LOGI(TRANS_CTRL, "trans proxy del channel by connId=%{public}d", connId);
418 }
419 }
420 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
421 TransProxyReleaseChannelList(&proxyChannelList, SOFTBUS_TRANS_PROXY_DISCONNECTED);
422 }
423
TransProxyDelByChannelId(int32_t channelId,ProxyChannelInfo * channelInfo)424 static int32_t TransProxyDelByChannelId(int32_t channelId, ProxyChannelInfo *channelInfo)
425 {
426 ProxyChannelInfo *removeNode = NULL;
427 ProxyChannelInfo *nextNode = NULL;
428
429 TRANS_CHECK_AND_RETURN_RET_LOGE(
430 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
431 TRANS_CHECK_AND_RETURN_RET_LOGE(
432 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
433
434 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
435 if (removeNode->channelId == channelId) {
436 if (channelInfo != NULL) {
437 (void)memcpy_s(channelInfo, sizeof(ProxyChannelInfo), removeNode, sizeof(ProxyChannelInfo));
438 }
439 ReleaseProxyChannelId(removeNode->channelId);
440 if (removeNode->appInfo.fastTransData != NULL) {
441 SoftBusFree((void *)removeNode->appInfo.fastTransData);
442 }
443 ListDelete(&(removeNode->node));
444 SoftBusFree(removeNode);
445 g_proxyChannelList->cnt--;
446 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
447 TRANS_LOGI(TRANS_CTRL, "trans proxy del channel by channelId=%{public}d", channelId);
448 return SOFTBUS_OK;
449 }
450 }
451 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
452 return SOFTBUS_TRANS_NODE_NOT_FOUND;
453 }
454
TransProxyResetChan(ProxyChannelInfo * chanInfo)455 static int32_t TransProxyResetChan(ProxyChannelInfo *chanInfo)
456 {
457 ProxyChannelInfo *removeNode = NULL;
458 ProxyChannelInfo *nextNode = NULL;
459
460 TRANS_CHECK_AND_RETURN_RET_LOGE(
461 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
462 TRANS_CHECK_AND_RETURN_RET_LOGE(
463 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
464
465 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
466 if (ResetChanIsEqual(removeNode->status, removeNode, chanInfo)) {
467 if (memcpy_s(chanInfo, sizeof(ProxyChannelInfo), removeNode, sizeof(ProxyChannelInfo)) != EOK) {
468 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
469 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
470 return SOFTBUS_MEM_ERR;
471 }
472 ReleaseProxyChannelId(removeNode->channelId);
473 if (removeNode->appInfo.fastTransData != NULL) {
474 SoftBusFree((void *)removeNode->appInfo.fastTransData);
475 }
476 ListDelete(&(removeNode->node));
477 SoftBusFree(removeNode);
478 g_proxyChannelList->cnt--;
479 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
480 TRANS_LOGI(TRANS_CTRL, "trans proxy reset channelId=%{public}d", chanInfo->channelId);
481 return SOFTBUS_OK;
482 }
483 }
484 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
485
486 return SOFTBUS_TRANS_NODE_NOT_FOUND;
487 }
488
TransProxyGetRecvMsgChanInfo(int16_t myId,int16_t peerId,ProxyChannelInfo * chanInfo)489 static int32_t TransProxyGetRecvMsgChanInfo(int16_t myId, int16_t peerId, ProxyChannelInfo *chanInfo)
490 {
491 ProxyChannelInfo *item = NULL;
492
493 TRANS_CHECK_AND_RETURN_RET_LOGE(
494 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
495 TRANS_CHECK_AND_RETURN_RET_LOGE(
496 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
497
498 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
499 if ((item->myId == myId) && (item->peerId == peerId)) {
500 if (item->status == PROXY_CHANNEL_STATUS_COMPLETED) {
501 item->timeout = 0;
502 }
503 if (memcpy_s(chanInfo, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo)) != EOK) {
504 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
505 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
506 return SOFTBUS_MEM_ERR;
507 }
508 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
509 return SOFTBUS_OK;
510 }
511 }
512 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
513 return SOFTBUS_TRANS_NODE_NOT_FOUND;
514 }
515
TransProxyKeepAliveChan(ProxyChannelInfo * chanInfo)516 static int32_t TransProxyKeepAliveChan(ProxyChannelInfo *chanInfo)
517 {
518 ProxyChannelInfo *item = NULL;
519
520 TRANS_CHECK_AND_RETURN_RET_LOGE(
521 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
522 TRANS_CHECK_AND_RETURN_RET_LOGE(
523 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
524
525 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
526 if (ChanIsEqual(item, chanInfo)) {
527 if (item->status == PROXY_CHANNEL_STATUS_KEEPLIVEING || item->status == PROXY_CHANNEL_STATUS_COMPLETED) {
528 item->timeout = 0;
529 item->status = PROXY_CHANNEL_STATUS_COMPLETED;
530 }
531 if (memcpy_s(chanInfo, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo)) != EOK) {
532 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
533 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
534 return SOFTBUS_MEM_ERR;
535 }
536 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
537 return SOFTBUS_OK;
538 }
539 }
540 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
541 return SOFTBUS_TRANS_NODE_NOT_FOUND;
542 }
543
TransProxyGetSendMsgChanInfo(int32_t channelId,ProxyChannelInfo * chanInfo)544 int32_t TransProxyGetSendMsgChanInfo(int32_t channelId, ProxyChannelInfo *chanInfo)
545 {
546 ProxyChannelInfo *item = NULL;
547
548 TRANS_CHECK_AND_RETURN_RET_LOGE(
549 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
550 TRANS_CHECK_AND_RETURN_RET_LOGE(
551 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
552
553 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
554 if (item->channelId == channelId) {
555 if (item->status == PROXY_CHANNEL_STATUS_COMPLETED) {
556 item->timeout = 0;
557 }
558 if (memcpy_s(chanInfo, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo)) != EOK) {
559 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
560 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
561 return SOFTBUS_MEM_ERR;
562 }
563 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
564 return SOFTBUS_OK;
565 }
566 }
567 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
568 return SOFTBUS_TRANS_NODE_NOT_FOUND;
569 }
570
TransProxyGetNewChanSeq(int32_t channelId)571 int32_t TransProxyGetNewChanSeq(int32_t channelId)
572 {
573 ProxyChannelInfo *item = NULL;
574 int32_t seq = 0;
575
576 TRANS_CHECK_AND_RETURN_RET_LOGE(
577 g_proxyChannelList != NULL, seq, TRANS_CTRL, "g_proxyChannelList is null");
578 TRANS_CHECK_AND_RETURN_RET_LOGE(
579 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, seq, TRANS_CTRL, "lock mutex fail!");
580
581 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
582 if (item->channelId == channelId) {
583 seq = item->seq;
584 item->seq++;
585 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
586 return seq;
587 }
588 }
589 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
590 return seq;
591 }
592
TransProxyGetAuthId(int32_t channelId,AuthHandle * authHandle)593 int32_t TransProxyGetAuthId(int32_t channelId, AuthHandle *authHandle)
594 {
595 TRANS_CHECK_AND_RETURN_RET_LOGE(
596 authHandle != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL, "authHandle is null");
597 ProxyChannelInfo *item = NULL;
598 TRANS_CHECK_AND_RETURN_RET_LOGE(
599 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
600 TRANS_CHECK_AND_RETURN_RET_LOGE(
601 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
602 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
603 if (item->channelId == channelId) {
604 *authHandle = item->authHandle;
605 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
606 return SOFTBUS_OK;
607 }
608 }
609 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
610 return SOFTBUS_TRANS_NODE_NOT_FOUND;
611 }
612
TransProxyGetSessionKeyByChanId(int32_t channelId,char * sessionKey,uint32_t sessionKeySize)613 int32_t TransProxyGetSessionKeyByChanId(int32_t channelId, char *sessionKey, uint32_t sessionKeySize)
614 {
615 TRANS_CHECK_AND_RETURN_RET_LOGE(
616 sessionKey != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL, "sessionKey is null");
617 ProxyChannelInfo *item = NULL;
618 TRANS_CHECK_AND_RETURN_RET_LOGE(
619 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
620 TRANS_CHECK_AND_RETURN_RET_LOGE(
621 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
622 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
623 if (item->channelId == channelId) {
624 if (item->status == PROXY_CHANNEL_STATUS_COMPLETED) {
625 item->timeout = 0;
626 }
627 if (memcpy_s(sessionKey, sessionKeySize, item->appInfo.sessionKey,
628 sizeof(item->appInfo.sessionKey)) != EOK) {
629 TRANS_LOGE(TRANS_CTRL, "memcpy_s fail!");
630 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
631 return SOFTBUS_MEM_ERR;
632 }
633 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
634 return SOFTBUS_OK;
635 }
636 }
637 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
638 TRANS_LOGE(TRANS_CTRL, "not found ChannelInfo by channelId=%{public}d", channelId);
639 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
640 }
641
TransProxyProcessErrMsg(ProxyChannelInfo * info,int32_t errCode)642 static inline void TransProxyProcessErrMsg(ProxyChannelInfo *info, int32_t errCode)
643 {
644 TRANS_LOGW(TRANS_CTRL, "TransProxyProcessErrMsg errCode=%{public}d", errCode);
645 TRANS_CHECK_AND_RETURN_LOGE(
646 TransProxyGetChanByChanId(info->myId, info) == SOFTBUS_OK, TRANS_CTRL, "TransProxyGetChanByChanId fail");
647 if ((info->appInfo.appType == APP_TYPE_NORMAL) || (info->appInfo.appType == APP_TYPE_AUTH)) {
648 TransProxyDelChanByChanId(info->channelId);
649 (void)TransProxyOpenProxyChannelFail(info->channelId, &(info->appInfo), errCode);
650 }
651 }
652
TransProxyGetAppInfo(int16_t myId,AppInfo * appInfo)653 static int32_t TransProxyGetAppInfo(int16_t myId, AppInfo *appInfo)
654 {
655 ProxyChannelInfo *item = NULL;
656
657 TRANS_CHECK_AND_RETURN_RET_LOGE(
658 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
659 TRANS_CHECK_AND_RETURN_RET_LOGE(
660 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
661
662 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
663 if (item->myId == myId) {
664 if (memcpy_s(appInfo, sizeof(AppInfo), &(item->appInfo), sizeof(item->appInfo)) != EOK) {
665 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
666 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
667 return SOFTBUS_MEM_ERR;
668 }
669 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
670 return SOFTBUS_OK;
671 }
672 }
673 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
674 return SOFTBUS_TRANS_NODE_NOT_FOUND;
675 }
676
TransProxyGetReqIdAndStatus(int32_t myId,int32_t * reqId,int8_t * status)677 static int32_t TransProxyGetReqIdAndStatus(int32_t myId, int32_t *reqId, int8_t *status)
678 {
679 TRANS_CHECK_AND_RETURN_RET_LOGE(
680 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "proxy channel list not init");
681
682 int32_t ret = SoftBusMutexLock(&g_proxyChannelList->lock);
683 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
684 ProxyChannelInfo *item = NULL;
685 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
686 if (item->myId == myId) {
687 *reqId = item->reqId;
688 *status = item->status;
689 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
690 return SOFTBUS_OK;
691 }
692 }
693 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
694 TRANS_LOGE(TRANS_CTRL, "not found proxyChannelInfo by channelId=%{public}d", myId);
695 return SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND;
696 }
697
698 static const ConfigTypeMap g_configTypeMap[] = {
699 { CHANNEL_TYPE_AUTH, BUSINESS_TYPE_BYTE, SOFTBUS_INT_AUTH_MAX_BYTES_LENGTH },
700 { CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, SOFTBUS_INT_AUTH_MAX_MESSAGE_LENGTH },
701 { CHANNEL_TYPE_PROXY, BUSINESS_TYPE_BYTE, SOFTBUS_INT_MAX_BYTES_NEW_LENGTH },
702 { CHANNEL_TYPE_PROXY, BUSINESS_TYPE_MESSAGE, SOFTBUS_INT_MAX_MESSAGE_NEW_LENGTH },
703 };
704
FindConfigType(int32_t channelType,int32_t businessType)705 static int32_t FindConfigType(int32_t channelType, int32_t businessType)
706 {
707 uint32_t size = (uint32_t)sizeof(g_configTypeMap) / sizeof(ConfigTypeMap);
708 for (uint32_t i = 0; i < size; i++) {
709 if ((g_configTypeMap[i].channelType == channelType) && (g_configTypeMap[i].businessType == businessType)) {
710 return g_configTypeMap[i].configType;
711 }
712 }
713 return SOFTBUS_CONFIG_TYPE_MAX;
714 }
715
TransGetLocalConfig(int32_t channelType,int32_t businessType,uint32_t * len)716 static int32_t TransGetLocalConfig(int32_t channelType, int32_t businessType, uint32_t *len)
717 {
718 ConfigType configType = (ConfigType)FindConfigType(channelType, businessType);
719 if (configType == SOFTBUS_CONFIG_TYPE_MAX) {
720 TRANS_LOGE(TRANS_CTRL, "Invalid channelType=%{public}d, businessType=%{public}d", channelType, businessType);
721 return SOFTBUS_INVALID_PARAM;
722 }
723 uint32_t maxLen;
724 if (SoftbusGetConfig(configType, (unsigned char *)&maxLen, sizeof(maxLen)) != SOFTBUS_OK) {
725 TRANS_LOGE(TRANS_CTRL, "get fail configType=%{public}d", configType);
726 return SOFTBUS_GET_CONFIG_VAL_ERR;
727 }
728 *len = maxLen;
729 TRANS_LOGI(TRANS_CTRL, "get local config len=%{public}u", *len);
730 return SOFTBUS_OK;
731 }
732
TransProxyProcessDataConfig(AppInfo * appInfo)733 static int32_t TransProxyProcessDataConfig(AppInfo *appInfo)
734 {
735 if (appInfo == NULL) {
736 TRANS_LOGE(TRANS_CTRL, "appInfo is null");
737 return SOFTBUS_INVALID_PARAM;
738 }
739 if (appInfo->businessType != BUSINESS_TYPE_MESSAGE && appInfo->businessType != BUSINESS_TYPE_BYTE) {
740 TRANS_LOGE(TRANS_CTRL, "invalid businessType=%{public}d", appInfo->businessType);
741 return SOFTBUS_OK;
742 }
743 if (appInfo->peerData.dataConfig != 0) {
744 appInfo->myData.dataConfig = MIN(appInfo->myData.dataConfig, appInfo->peerData.dataConfig);
745 TRANS_LOGI(TRANS_CTRL, "process dataConfig succ. dataConfig=%{public}u", appInfo->myData.dataConfig);
746 return SOFTBUS_OK;
747 }
748 ConfigType configType = appInfo->businessType == BUSINESS_TYPE_BYTE ? SOFTBUS_INT_PROXY_MAX_BYTES_LENGTH :
749 SOFTBUS_INT_PROXY_MAX_MESSAGE_LENGTH;
750 if (SoftbusGetConfig(configType, (unsigned char *)&appInfo->myData.dataConfig,
751 sizeof(appInfo->myData.dataConfig)) != SOFTBUS_OK) {
752 TRANS_LOGE(TRANS_CTRL, "get config failed, configType=%{public}d", configType);
753 return SOFTBUS_GET_CONFIG_VAL_ERR;
754 }
755 TRANS_LOGI(TRANS_CTRL, "process dataConfig=%{public}d", appInfo->myData.dataConfig);
756 return SOFTBUS_OK;
757 }
758
TransProxyHandshakeUnpackErrMsg(ProxyChannelInfo * info,const ProxyMessage * msg,int32_t * errCode)759 static int32_t TransProxyHandshakeUnpackErrMsg(ProxyChannelInfo *info, const ProxyMessage *msg, int32_t *errCode)
760 {
761 if (errCode == NULL) {
762 TRANS_LOGE(TRANS_CTRL, "errCode is invalid.");
763 return SOFTBUS_INVALID_PARAM;
764 }
765 int32_t ret = TransProxyUnPackHandshakeErrMsg(msg->data, errCode, msg->dateLen);
766 if (ret == SOFTBUS_OK) {
767 TransEventExtra extra = {
768 .socketName = NULL,
769 .peerNetworkId = NULL,
770 .calleePkg = NULL,
771 .callerPkg = NULL,
772 .channelId = info->myId,
773 .peerChannelId = info->peerId,
774 .errcode = *errCode,
775 .result = EVENT_STAGE_RESULT_FAILED
776 };
777 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_HANDSHAKE_REPLY, extra);
778 TransAuditExtra auditMsgExtra = {
779 .hostPkg = NULL,
780 .localIp = NULL,
781 .localPort = NULL,
782 .localDevId = NULL,
783 .localSessName = NULL,
784 .peerIp = NULL,
785 .peerPort = NULL,
786 .peerDevId = NULL,
787 .peerSessName = NULL,
788 .result = TRANS_AUDIT_DISCONTINUE,
789 .errcode = *errCode,
790 .auditType = AUDIT_EVENT_MSG_ERROR,
791 .localChannelId = info->myId,
792 .peerChannelId = info->peerId,
793 };
794 TRANS_AUDIT(AUDIT_SCENE_OPEN_SESSION, auditMsgExtra);
795 return SOFTBUS_OK;
796 }
797 return ret;
798 }
799
TransProxyHandshakeUnpackRightMsg(ProxyChannelInfo * info,const ProxyMessage * msg,int32_t errCode,uint16_t * fastDataSize)800 static int32_t TransProxyHandshakeUnpackRightMsg(
801 ProxyChannelInfo *info, const ProxyMessage *msg, int32_t errCode, uint16_t *fastDataSize)
802 {
803 if (fastDataSize == NULL) {
804 TRANS_LOGE(TRANS_CTRL, "fastDataSize is invalid.");
805 return SOFTBUS_INVALID_PARAM;
806 }
807 int32_t ret = TransProxyUnpackHandshakeAckMsg(msg->data, info, msg->dateLen, fastDataSize);
808 if (ret != SOFTBUS_OK) {
809 TransAuditExtra auditPacketExtra = {
810 .hostPkg = NULL,
811 .localIp = NULL,
812 .localPort = NULL,
813 .localDevId = NULL,
814 .localSessName = NULL,
815 .peerIp = NULL,
816 .peerPort = NULL,
817 .peerDevId = NULL,
818 .peerSessName = NULL,
819 .result = TRANS_AUDIT_DISCONTINUE,
820 .errcode = errCode,
821 .auditType = AUDIT_EVENT_PACKETS_ERROR,
822 .localChannelId = info->myId,
823 .peerChannelId = info->peerId,
824 };
825 TRANS_AUDIT(AUDIT_SCENE_OPEN_SESSION, auditPacketExtra);
826 TRANS_LOGE(TRANS_CTRL, "UnpackHandshakeAckMsg failed");
827 return ret;
828 }
829 TRANS_LOGI(TRANS_CTRL,
830 "recv Handshake ack myChannelid=%{public}d, peerChannelId=%{public}d, identity=%{public}s, crc=%{public}d",
831 info->myId, info->peerId, info->identity, info->appInfo.crc);
832 return SOFTBUS_OK;
833 }
834
TransProxyProcessHandshakeAckMsg(const ProxyMessage * msg)835 void TransProxyProcessHandshakeAckMsg(const ProxyMessage *msg)
836 {
837 uint16_t fastDataSize = 0;
838 ProxyChannelInfo info = {
839 .myId = msg->msgHead.myId,
840 .peerId = msg->msgHead.peerId
841 };
842
843 if (TransProxyGetAppInfo(info.myId, &(info.appInfo)) != SOFTBUS_OK) {
844 TRANS_LOGE(TRANS_CTRL, "failed to get peer data info");
845 return;
846 }
847 int32_t errCode = SOFTBUS_OK;
848 if (TransProxyHandshakeUnpackErrMsg(&info, msg, &errCode) == SOFTBUS_OK) {
849 TransProxyProcessErrMsg(&info, errCode);
850 goto EXIT;
851 }
852 if (TransProxyHandshakeUnpackRightMsg(&info, msg, errCode, &fastDataSize) != SOFTBUS_OK) {
853 goto EXIT;
854 }
855
856 if (TransProxyProcessDataConfig(&(info.appInfo)) != SOFTBUS_OK) {
857 TRANS_LOGE(TRANS_CTRL, "ProcessDataConfig failed");
858 goto EXIT;
859 }
860
861 if (TransProxyUpdateAckInfo(&info) != SOFTBUS_OK) {
862 TRANS_LOGE(TRANS_CTRL, "UpdateAckInfo failed");
863 goto EXIT;
864 }
865
866 info.appInfo.peerData.channelId = msg->msgHead.peerId;
867 if (info.appInfo.fastTransDataSize <= 0 || (fastDataSize > 0 && fastDataSize == info.appInfo.fastTransDataSize)) {
868 (void)OnProxyChannelOpened(info.channelId, &(info.appInfo), PROXY_CHANNEL_CLIENT);
869 } else {
870 uint32_t outLen;
871 char *buf = TransProxyPackFastData(&(info.appInfo), &outLen);
872 if (buf == NULL) {
873 TRANS_LOGE(TRANS_CTRL, "failed to pack bytes.");
874 goto EXIT;
875 }
876 (void)TransSendMsg(info.channelId, CHANNEL_TYPE_PROXY, buf, outLen, info.appInfo.businessType);
877 (void)OnProxyChannelOpened(info.channelId, &(info.appInfo), PROXY_CHANNEL_CLIENT);
878 SoftBusFree(buf);
879 }
880 EXIT:
881 (void)memset_s(info.appInfo.sessionKey, sizeof(info.appInfo.sessionKey), 0, sizeof(info.appInfo.sessionKey));
882 return;
883 }
884
TransProxyGetLocalInfo(ProxyChannelInfo * chan)885 static int32_t TransProxyGetLocalInfo(ProxyChannelInfo *chan)
886 {
887 bool noNeedGetPkg = (chan->appInfo.appType == APP_TYPE_INNER) ||
888 ((chan->appInfo.appType == APP_TYPE_AUTH) && (IsNoPkgNameSession(chan->appInfo.myData.sessionName)));
889 if (!noNeedGetPkg) {
890 if (TransProxyGetPkgName(chan->appInfo.myData.sessionName,
891 chan->appInfo.myData.pkgName, sizeof(chan->appInfo.myData.pkgName)) != SOFTBUS_OK) {
892 TRANS_LOGE(TRANS_CTRL, "proc handshake get pkg name fail");
893 return SOFTBUS_TRANS_PEER_SESSION_NOT_CREATED;
894 }
895
896 if (TransProxyGetUidAndPidBySessionName(chan->appInfo.myData.sessionName,
897 &chan->appInfo.myData.uid, &chan->appInfo.myData.pid) != SOFTBUS_OK) {
898 TRANS_LOGE(TRANS_CTRL, "proc handshake get uid pid fail");
899 return SOFTBUS_TRANS_PEER_SESSION_NOT_CREATED;
900 }
901 }
902
903 InfoKey key = STRING_KEY_UUID;
904 if (chan->appInfo.appType == APP_TYPE_AUTH) {
905 key = STRING_KEY_DEV_UDID;
906 }
907 int32_t ret = LnnGetLocalStrInfo(key, chan->appInfo.myData.deviceId, sizeof(chan->appInfo.myData.deviceId));
908 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "Handshake get local info fail");
909 return SOFTBUS_OK;
910 }
911
CheckAppTypeAndMsgHead(const ProxyMessageHead * msgHead,const AppInfo * appInfo)912 static inline int32_t CheckAppTypeAndMsgHead(const ProxyMessageHead *msgHead, const AppInfo *appInfo)
913 {
914 if (((msgHead->cipher & ENCRYPTED) == 0) && (appInfo->appType != APP_TYPE_AUTH)) {
915 return SOFTBUS_TRANS_PROXY_ERROR_APP_TYPE;
916 }
917 return SOFTBUS_OK;
918 }
919
SelectRouteType(ConnectType type,RouteType * routeType)920 static void SelectRouteType(ConnectType type, RouteType *routeType)
921 {
922 if (type == CONNECT_TCP) {
923 *routeType = WIFI_STA;
924 } else if (type == CONNECT_BR) {
925 *routeType = BT_BR;
926 } else if (type == CONNECT_BLE) {
927 *routeType = BT_BLE;
928 } else if (type == CONNECT_BLE_DIRECT) {
929 *routeType = BT_BLE;
930 }
931 }
932
ConstructProxyChannelInfo(ProxyChannelInfo * chan,const ProxyMessage * msg,int16_t newChanId,const ConnectionInfo * info)933 static void ConstructProxyChannelInfo(
934 ProxyChannelInfo *chan, const ProxyMessage *msg, int16_t newChanId, const ConnectionInfo *info)
935 {
936 // always be client when communicating with WinPC
937 chan->isServer = (msg->msgHead.cipher & CS_MODE) == 0 ? 0 : 1;
938 if (chan->isServer == 0) {
939 chan->deviceTypeIsWinpc = true;
940 }
941 chan->status = PROXY_CHANNEL_STATUS_COMPLETED;
942 chan->connId = msg->connId;
943 chan->myId = newChanId;
944 chan->channelId = newChanId;
945 chan->peerId = msg->msgHead.peerId;
946 chan->authHandle = msg->authHandle;
947 chan->type = info->type;
948 if (chan->type == CONNECT_BLE || chan->type == CONNECT_BLE_DIRECT) {
949 chan->bleProtocolType = info->bleInfo.protocol;
950 }
951
952 SelectRouteType(info->type, &chan->appInfo.routeType);
953 }
954
TransProxyFillDataConfig(AppInfo * appInfo)955 static int32_t TransProxyFillDataConfig(AppInfo *appInfo)
956 {
957 if (appInfo == NULL) {
958 TRANS_LOGE(TRANS_CTRL, "appInfo is null");
959 return SOFTBUS_INVALID_PARAM;
960 }
961 if (appInfo->appType == APP_TYPE_AUTH) {
962 appInfo->businessType = BUSINESS_TYPE_BYTE;
963 }
964 if (appInfo->businessType != BUSINESS_TYPE_MESSAGE && appInfo->businessType != BUSINESS_TYPE_BYTE) {
965 TRANS_LOGI(TRANS_CTRL, "invalid businessType=%{public}d", appInfo->businessType);
966 return SOFTBUS_OK;
967 }
968 if (appInfo->peerData.dataConfig != 0) {
969 uint32_t localDataConfig = 0;
970 if (TransGetLocalConfig(CHANNEL_TYPE_PROXY, appInfo->businessType, &localDataConfig) != SOFTBUS_OK) {
971 TRANS_LOGE(TRANS_CTRL, "get local config failed, businessType=%{public}d", appInfo->businessType);
972 return SOFTBUS_GET_CONFIG_VAL_ERR;
973 }
974 appInfo->myData.dataConfig = MIN(localDataConfig, appInfo->peerData.dataConfig);
975 TRANS_LOGI(TRANS_CTRL, "fill dataConfig success. dataConfig=%{public}u", appInfo->myData.dataConfig);
976 return SOFTBUS_OK;
977 }
978 ConfigType configType = appInfo->businessType == BUSINESS_TYPE_BYTE ? SOFTBUS_INT_PROXY_MAX_BYTES_LENGTH :
979 SOFTBUS_INT_PROXY_MAX_MESSAGE_LENGTH;
980 if (SoftbusGetConfig(configType, (unsigned char *)&appInfo->myData.dataConfig,
981 sizeof(appInfo->myData.dataConfig)) != SOFTBUS_OK) {
982 TRANS_LOGE(TRANS_CTRL, "get config failed, configType=%{public}d", configType);
983 return SOFTBUS_GET_CONFIG_VAL_ERR;
984 }
985 TRANS_LOGD(TRANS_CTRL, "fill dataConfig=%{public}d", appInfo->myData.dataConfig);
986 return SOFTBUS_OK;
987 }
988
TransProxyReportAuditEvent(int32_t ret)989 static void TransProxyReportAuditEvent(int32_t ret)
990 {
991 TransAuditExtra extra = {
992 .hostPkg = NULL,
993 .localIp = NULL,
994 .localPort = NULL,
995 .localDevId = NULL,
996 .localSessName = NULL,
997 .peerIp = NULL,
998 .peerPort = NULL,
999 .peerDevId = NULL,
1000 .peerSessName = NULL,
1001 .result = TRANS_AUDIT_DISCONTINUE,
1002 .errcode = ret,
1003 .auditType = AUDIT_EVENT_PACKETS_ERROR,
1004 };
1005 TRANS_AUDIT(AUDIT_SCENE_OPEN_SESSION, extra);
1006 }
1007
TransProxyFillChannelInfo(const ProxyMessage * msg,ProxyChannelInfo * chan)1008 static int32_t TransProxyFillChannelInfo(const ProxyMessage *msg, ProxyChannelInfo *chan)
1009 {
1010 int32_t ret = TransProxyUnpackHandshakeMsg(msg->data, chan, msg->dateLen);
1011 if (ret != SOFTBUS_OK) {
1012 TransProxyReportAuditEvent(ret);
1013 TRANS_LOGE(TRANS_CTRL, "UnpackHandshakeMsg fail.");
1014 return ret;
1015 }
1016 if ((chan->appInfo.appType == APP_TYPE_AUTH) &&
1017 (!CheckSessionNameValidOnAuthChannel(chan->appInfo.myData.sessionName))) {
1018 TRANS_LOGE(TRANS_CTRL, "proxy auth check sessionname valid.");
1019 return SOFTBUS_TRANS_AUTH_NOTALLOW_OPENED;
1020 }
1021
1022 if (CheckAppTypeAndMsgHead(&msg->msgHead, &chan->appInfo) != SOFTBUS_OK) {
1023 TRANS_LOGE(TRANS_CTRL, "only auth channel surpport plain text data");
1024 return SOFTBUS_TRANS_PROXY_ERROR_APP_TYPE;
1025 }
1026
1027 ConnectionInfo info;
1028 (void)memset_s(&info, sizeof(ConnectionInfo), 0, sizeof(ConnectionInfo));
1029 ret = ConnGetConnectionInfo(msg->connId, &info);
1030 if (ret != SOFTBUS_OK) {
1031 TRANS_LOGE(TRANS_CTRL, "GetConnectionInfo fail. connId=%{public}u", msg->connId);
1032 return ret;
1033 }
1034 ConnectType type;
1035 if (ConnGetTypeByConnectionId(msg->connId, &type) != SOFTBUS_OK) {
1036 return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
1037 }
1038 SelectRouteType(type, &chan->appInfo.routeType);
1039
1040 int16_t newChanId = (int16_t)(GenerateChannelId(false));
1041 ConstructProxyChannelInfo(chan, msg, newChanId, &info);
1042
1043 if (chan->appInfo.appType == APP_TYPE_NORMAL && chan->appInfo.callingTokenId != TOKENID_NOT_SET &&
1044 TransCheckServerAccessControl(chan->appInfo.callingTokenId) != SOFTBUS_OK) {
1045 return SOFTBUS_TRANS_CHECK_ACL_FAILED;
1046 }
1047
1048 if (CheckSecLevelPublic(chan->appInfo.myData.sessionName, chan->appInfo.peerData.sessionName) != SOFTBUS_OK) {
1049 return SOFTBUS_PERMISSION_SERVER_DENIED;
1050 }
1051 ret = TransProxyGetLocalInfo(chan);
1052 if (ret != SOFTBUS_OK) {
1053 TRANS_LOGE(TRANS_CTRL, "TransProxyGetLocalInfo fail. ret=%{public}d.", ret);
1054 return ret;
1055 }
1056
1057 ret = TransProxyFillDataConfig(&chan->appInfo);
1058 if (ret != SOFTBUS_OK) {
1059 TRANS_LOGE(TRANS_CTRL, "fill dataConfig fail.");
1060 return ret;
1061 }
1062 return SOFTBUS_OK;
1063 }
1064
TransProxyProcessHandshakeAuthMsg(const ProxyMessage * msg)1065 void TransProxyProcessHandshakeAuthMsg(const ProxyMessage *msg)
1066 {
1067 AppInfo appInfo;
1068 int32_t ret = TransProxyGetAppInfoByChanId(msg->msgHead.myId, &appInfo);
1069 (void)memset_s(appInfo.sessionKey, sizeof(appInfo.sessionKey), 0, sizeof(appInfo.sessionKey));
1070 if (ret != SOFTBUS_OK) {
1071 return;
1072 }
1073 if (((uint32_t)appInfo.transFlag & TRANS_FLAG_HAS_CHANNEL_AUTH) == 0) {
1074 return;
1075 }
1076 int64_t authSeq = appInfo.authSeq;
1077 AuthSessionProcessAuthData(authSeq, (uint8_t *)msg->data, msg->dateLen);
1078 }
1079
TransProxyFastDataRecv(ProxyChannelInfo * chan)1080 static void TransProxyFastDataRecv(ProxyChannelInfo *chan)
1081 {
1082 TRANS_LOGD(TRANS_CTRL, "begin, fastTransDataSize=%{public}d", chan->appInfo.fastTransDataSize);
1083 TransReceiveData receiveData;
1084 receiveData.data = (void *)chan->appInfo.fastTransData;
1085 if (chan->appInfo.businessType == BUSINESS_TYPE_MESSAGE && chan->appInfo.routeType == WIFI_STA) {
1086 receiveData.dataLen = chan->appInfo.fastTransDataSize + FAST_EXT_MSG_SIZE;
1087 } else {
1088 receiveData.dataLen = chan->appInfo.fastTransDataSize + FAST_EXT_BYTE_SIZE;
1089 }
1090 if (chan->appInfo.businessType == BUSINESS_TYPE_MESSAGE) {
1091 receiveData.dataType = TRANS_SESSION_MESSAGE;
1092 } else {
1093 receiveData.dataType = TRANS_SESSION_BYTES;
1094 }
1095 if (NotifyClientMsgReceived(chan->appInfo.myData.pkgName, chan->appInfo.myData.pid,
1096 chan->channelId, &receiveData) != SOFTBUS_OK) {
1097 TRANS_LOGE(TRANS_CTRL, "TransProxyFastDataRecv err");
1098 chan->appInfo.fastTransDataSize = 0;
1099 }
1100 TRANS_LOGD(TRANS_CTRL, "ok");
1101 return;
1102 }
1103
ReleaseChannelInfo(ProxyChannelInfo * chan)1104 static void ReleaseChannelInfo(ProxyChannelInfo *chan)
1105 {
1106 if (chan == NULL) {
1107 return;
1108 }
1109 if (chan->appInfo.fastTransData != NULL) {
1110 SoftBusFree((void*)chan->appInfo.fastTransData);
1111 }
1112 SoftBusFree(chan);
1113 }
1114
FillProxyHandshakeExtra(TransEventExtra * extra,ProxyChannelInfo * chan,char * socketName,NodeInfo * nodeInfo)1115 static void FillProxyHandshakeExtra(
1116 TransEventExtra *extra, ProxyChannelInfo *chan, char *socketName, NodeInfo *nodeInfo)
1117 {
1118 if (strcpy_s(socketName, SESSION_NAME_SIZE_MAX, chan->appInfo.myData.sessionName) != EOK) {
1119 TRANS_LOGW(TRANS_CTRL, "strcpy_s socketName failed");
1120 }
1121 extra->calleePkg = NULL;
1122 extra->callerPkg = NULL;
1123 extra->channelId = chan->myId;
1124 extra->peerChannelId = chan->peerId;
1125 extra->socketName = socketName;
1126 extra->authId = chan->authHandle.authId;
1127 extra->connectionId = (int32_t)chan->connId;
1128 extra->channelType = chan->appInfo.appType == APP_TYPE_AUTH ? CHANNEL_TYPE_AUTH : CHANNEL_TYPE_PROXY;
1129 extra->linkType = chan->type;
1130
1131 if (chan->appInfo.appType == APP_TYPE_AUTH &&
1132 strcpy_s(nodeInfo->deviceInfo.deviceUdid, UDID_BUF_LEN, chan->appInfo.peerData.deviceId) != EOK) {
1133 extra->peerUdid = nodeInfo->deviceInfo.deviceUdid;
1134 } else if (chan->appInfo.appType != APP_TYPE_AUTH &&
1135 LnnGetRemoteNodeInfoById(chan->appInfo.peerData.deviceId, CATEGORY_UUID, nodeInfo) == SOFTBUS_OK) {
1136 extra->peerUdid = nodeInfo->deviceInfo.deviceUdid;
1137 extra->peerDevVer = nodeInfo->deviceInfo.deviceVersion;
1138 }
1139 if (LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, nodeInfo->masterUdid, UDID_BUF_LEN) == SOFTBUS_OK) {
1140 extra->localUdid = nodeInfo->masterUdid;
1141 }
1142 }
1143
TransProxyProcessHandshake(ProxyChannelInfo * chan,const ProxyMessage * msg)1144 static int32_t TransProxyProcessHandshake(ProxyChannelInfo *chan, const ProxyMessage *msg)
1145 {
1146 int32_t ret = OnProxyChannelOpened(chan->channelId, &(chan->appInfo), PROXY_CHANNEL_SERVER);
1147 if (ret != SOFTBUS_OK) {
1148 TRANS_LOGE(TRANS_CTRL, "OnProxyChannelOpened fail channelId=%{public}d", chan->channelId);
1149 (void)TransProxyAckHandshake(msg->connId, chan, ret);
1150 return ret;
1151 }
1152 if (chan->appInfo.fastTransData != NULL && chan->appInfo.fastTransDataSize > 0) {
1153 TransProxyFastDataRecv(chan);
1154 }
1155 chan->appInfo.myHandleId = 0;
1156
1157 if ((ret = TransProxyAckHandshake(msg->connId, chan, SOFTBUS_OK)) != SOFTBUS_OK) {
1158 TRANS_LOGE(
1159 TRANS_CTRL, "AckHandshake fail channelId=%{public}d, connId=%{public}u", chan->channelId, msg->connId);
1160 OnProxyChannelClosed(chan->channelId, &(chan->appInfo));
1161 return ret;
1162 }
1163 if ((ret = OnProxyChannelBind(chan->channelId, &(chan->appInfo))) != SOFTBUS_OK) {
1164 TRANS_LOGE(TRANS_CTRL, "OnProxyChannelBind fail channelId=%{public}d, connId=%{public}u", chan->channelId,
1165 msg->connId);
1166 return ret;
1167 }
1168
1169 return SOFTBUS_OK;
1170 }
1171
TransProxyProcessHandshakeMsg(const ProxyMessage * msg)1172 void TransProxyProcessHandshakeMsg(const ProxyMessage *msg)
1173 {
1174 if (msg == NULL) {
1175 TRANS_LOGE(TRANS_CTRL, "param invalid");
1176 return;
1177 }
1178 TRANS_LOGI(TRANS_CTRL, "recv Handshake myChannelId=%{public}d, peerChannelId=%{public}d", msg->msgHead.myId,
1179 msg->msgHead.peerId);
1180 ProxyChannelInfo *chan = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1181 TRANS_CHECK_AND_RETURN_LOGW(!(chan == NULL), TRANS_CTRL, "proxy handshake calloc failed.");
1182
1183 int32_t ret = TransProxyFillChannelInfo(msg, chan);
1184 if ((ret == SOFTBUS_TRANS_PEER_SESSION_NOT_CREATED || ret == SOFTBUS_TRANS_CHECK_ACL_FAILED) &&
1185 (TransProxyAckHandshake(msg->connId, chan, ret) != SOFTBUS_OK)) {
1186 TRANS_LOGE(TRANS_CTRL, "ErrHandshake fail, connId=%{public}u.", msg->connId);
1187 }
1188 char tmpSocketName[SESSION_NAME_SIZE_MAX] = { 0 };
1189 NodeInfo nodeInfo;
1190 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1191 TransEventExtra extra = { 0 };
1192 FillProxyHandshakeExtra(&extra, chan, tmpSocketName, &nodeInfo);
1193
1194 if (ret != SOFTBUS_OK) {
1195 ReleaseProxyChannelId(chan->channelId);
1196 ReleaseChannelInfo(chan);
1197 goto EXIT_ERR;
1198 }
1199
1200 extra.result = EVENT_STAGE_RESULT_OK;
1201 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL_SERVER, EVENT_STAGE_HANDSHAKE_START, extra);
1202 ret = TransProxyProcessHandshake(chan, msg);
1203 if (ret != SOFTBUS_OK) {
1204 goto EXIT_ERR;
1205 }
1206 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL_SERVER, EVENT_STAGE_HANDSHAKE_REPLY, extra);
1207
1208 TransCreateConnByConnId(msg->connId, (bool)chan->isServer);
1209 if ((ret = TransProxyAddChanItem(chan)) != SOFTBUS_OK) {
1210 TRANS_LOGE(TRANS_CTRL, "AddChanItem fail");
1211 ReleaseProxyChannelId(chan->channelId);
1212 ReleaseChannelInfo(chan);
1213 goto EXIT_ERR;
1214 }
1215
1216 return;
1217 EXIT_ERR:
1218 extra.result = EVENT_STAGE_RESULT_FAILED;
1219 extra.errcode = ret;
1220 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL_SERVER, EVENT_STAGE_HANDSHAKE_REPLY, extra);
1221 }
1222
TransGetRemoteDeviceIdByReqId(int32_t requestId,char * peerNetworkId)1223 static int32_t TransGetRemoteDeviceIdByReqId(int32_t requestId, char *peerNetworkId)
1224 {
1225 TRANS_CHECK_AND_RETURN_RET_LOGE(
1226 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "proxy channel list not init");
1227
1228 int32_t ret = SoftBusMutexLock(&g_proxyChannelList->lock);
1229 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
1230
1231 ProxyChannelInfo *item = NULL;
1232 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
1233 if (item->reqId == requestId) {
1234 if (memcpy_s(peerNetworkId, DEVICE_ID_SIZE_MAX, item->appInfo.peerNetWorkId, DEVICE_ID_SIZE_MAX) != EOK) {
1235 TRANS_LOGE(TRANS_CTRL, "memcpy_s peerNetworkId failed");
1236 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1237 return SOFTBUS_MEM_ERR;
1238 }
1239 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1240 return SOFTBUS_OK;
1241 }
1242 }
1243 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1244 TRANS_LOGE(TRANS_CTRL, "proxy channel not found by requestId=%{public}d", requestId);
1245 return SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND;
1246 }
1247
TransProxyProcessReNegotiateMsg(const ProxyMessage * msg,const ProxyChannelInfo * info)1248 static int32_t TransProxyProcessReNegotiateMsg(const ProxyMessage *msg, const ProxyChannelInfo *info)
1249 {
1250 TRANS_LOGW(TRANS_CTRL, "receive reNegotiate msg, retry one time");
1251 AuthConnInfo authConnInfo;
1252 (void)memset_s(&authConnInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
1253 int32_t ret = GetAuthConnInfoByConnId(msg->connId, &authConnInfo);
1254 if (ret != SOFTBUS_OK) {
1255 TRANS_LOGE(TRANS_CTRL, "get authConnInfo by connId=%{public}u fail, ret=%{public}d", msg->connId, ret);
1256 return ret;
1257 }
1258
1259 ret = TransReNegotiateSessionKey(&authConnInfo, info->myId);
1260 if (ret != SOFTBUS_OK) {
1261 TransProxyNegoSessionKeyFail(info->myId, ret);
1262 TRANS_LOGE(TRANS_CTRL, "generate session key failed ret=%{public}d", ret);
1263 return ret;
1264 }
1265 TRANS_LOGI(TRANS_CTRL, "call regenerate sessionKey succ");
1266 return SOFTBUS_OK;
1267 }
1268
TransProxyProcessResetMsgHelper(const ProxyChannelInfo * info,const ProxyMessage * msg)1269 static void TransProxyProcessResetMsgHelper(const ProxyChannelInfo *info, const ProxyMessage *msg)
1270 {
1271 if (info->status == PROXY_CHANNEL_STATUS_HANDSHAKEING) {
1272 int32_t errCode = ((msg->msgHead.cipher & BAD_CIPHER) == BAD_CIPHER) ?
1273 SOFTBUS_TRANS_BAD_KEY : SOFTBUS_TRANS_HANDSHAKE_ERROR;
1274 TransProxyUnPackRestErrMsg(msg->data, &errCode, msg->dateLen);
1275 TRANS_LOGE(TRANS_CTRL, "TransProxyProcessResetMsg errCode=%{public}d", errCode);
1276 TransProxyOpenProxyChannelFail(info->channelId, &(info->appInfo), errCode);
1277 } else if (info->status == PROXY_CHANNEL_STATUS_COMPLETED) {
1278 TransEventExtra extra = {
1279 .socketName = NULL,
1280 .peerNetworkId = NULL,
1281 .calleePkg = NULL,
1282 .callerPkg = NULL,
1283 .channelId = msg->msgHead.myId,
1284 .peerChannelId = msg->msgHead.peerId,
1285 .result = EVENT_STAGE_RESULT_OK
1286 };
1287 TRANS_EVENT(EVENT_SCENE_CLOSE_CHANNEL_PASSIVE, EVENT_STAGE_CLOSE_CHANNEL, extra);
1288 OnProxyChannelClosed(info->channelId, &(info->appInfo));
1289 }
1290 (void)TransProxyCloseConnChannelReset(msg->connId, (info->isServer == 0), info->isServer, info->deviceTypeIsWinpc);
1291 if ((msg->msgHead.cipher & BAD_CIPHER) == BAD_CIPHER) {
1292 TRANS_LOGE(TRANS_CTRL, "clear bad key cipher=%{public}d, authId=%{public}" PRId64 ", keyIndex=%{public}d",
1293 msg->msgHead.cipher, msg->authHandle.authId, msg->keyIndex);
1294 RemoveAuthSessionKeyByIndex(msg->authHandle.authId, msg->keyIndex, (AuthLinkType)msg->authHandle.type);
1295 }
1296 }
1297
TransProxyProcessResetMsg(const ProxyMessage * msg)1298 void TransProxyProcessResetMsg(const ProxyMessage *msg)
1299 {
1300 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1301 if (info == NULL) {
1302 TRANS_LOGE(TRANS_CTRL, "ProxyProcessResetMsg calloc failed.");
1303 return;
1304 }
1305
1306 TRANS_LOGI(TRANS_CTRL, "recv reset myChannelId=%{public}d, peerChanelId=%{public}d, cipher=%{public}d",
1307 msg->msgHead.myId, msg->msgHead.peerId, msg->msgHead.cipher);
1308 if (TransProxyUnpackIdentity(msg->data, info->identity, sizeof(info->identity), msg->dateLen) != SOFTBUS_OK) {
1309 TRANS_LOGE(TRANS_CTRL, "reset identity fail");
1310 SoftBusFree(info);
1311 return;
1312 }
1313
1314 info->peerId = msg->msgHead.peerId;
1315 info->myId = msg->msgHead.myId;
1316
1317 if (TransProxyGetAppInfo(info->myId, &(info->appInfo)) != SOFTBUS_OK) {
1318 TRANS_LOGE(TRANS_CTRL, "fail to get peer data info");
1319 SoftBusFree(info);
1320 return;
1321 }
1322
1323 if (TransProxyGetReqIdAndStatus(info->myId, &info->reqId, &info->status) != SOFTBUS_OK) {
1324 TRANS_LOGE(TRANS_CTRL, "fail to get conn reqId");
1325 goto EXIT;
1326 }
1327
1328 if (CheckAppTypeAndMsgHead(&msg->msgHead, &info->appInfo) != SOFTBUS_OK) {
1329 TRANS_LOGE(TRANS_CTRL, "only auth channel surpport plain text data");
1330 goto EXIT;
1331 }
1332
1333 if (info->status == PROXY_CHANNEL_STATUS_HANDSHAKEING &&
1334 (msg->msgHead.cipher & AUTH_SINGLE_CIPHER) == AUTH_SINGLE_CIPHER &&
1335 TransProxyProcessReNegotiateMsg(msg, info) == SOFTBUS_OK) {
1336 goto EXIT;
1337 }
1338
1339 if (TransProxyResetChan(info) != SOFTBUS_OK) {
1340 TRANS_LOGE(TRANS_CTRL, "reset chan fail mychannelId=%{public}d, peerChannelId=%{public}d", msg->msgHead.myId,
1341 msg->msgHead.peerId);
1342 goto EXIT;
1343 }
1344
1345 TransProxyProcessResetMsgHelper(info, msg);
1346 EXIT:
1347 (void)memset_s(info->appInfo.sessionKey, sizeof(info->appInfo.sessionKey), 0, sizeof(info->appInfo.sessionKey));
1348 SoftBusFree(info);
1349 return;
1350 }
1351
TransProxyProcessKeepAlive(const ProxyMessage * msg)1352 void TransProxyProcessKeepAlive(const ProxyMessage *msg)
1353 {
1354 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1355 if (info == NULL) {
1356 TRANS_LOGE(TRANS_CTRL, "ProxyProcessKeepAlive calloc failed.");
1357 return;
1358 }
1359
1360 TRANS_LOGI(TRANS_CTRL, "recv keepalive myChannelId=%{public}d, peerChannelId=%{public}d", msg->msgHead.myId,
1361 msg->msgHead.peerId);
1362 if (TransProxyUnpackIdentity(msg->data, info->identity, sizeof(info->identity), msg->dateLen) != SOFTBUS_OK) {
1363 TRANS_LOGE(TRANS_CTRL, "keep alive unpack identity fail");
1364 SoftBusFree(info);
1365 return;
1366 }
1367 info->peerId = msg->msgHead.peerId;
1368 info->myId = msg->msgHead.myId;
1369
1370 if (TransProxyKeepAliveChan(info) != SOFTBUS_OK) {
1371 TRANS_LOGE(TRANS_CTRL, "reset keep alive proc fail myChannelId=%{public}d, peerChannelId=%{public}d",
1372 msg->msgHead.myId, msg->msgHead.peerId);
1373 SoftBusFree(info);
1374 return;
1375 }
1376
1377 TransProxyAckKeepalive(info);
1378 (void)memset_s(info->appInfo.sessionKey, sizeof(info->appInfo.sessionKey), 0, sizeof(info->appInfo.sessionKey));
1379 SoftBusFree(info);
1380 }
1381
TransProxyProcessKeepAliveAck(const ProxyMessage * msg)1382 void TransProxyProcessKeepAliveAck(const ProxyMessage *msg)
1383 {
1384 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1385 if (info == NULL) {
1386 TRANS_LOGE(TRANS_CTRL, "ProxyProcessKeepAliveAck calloc failed.");
1387 return;
1388 }
1389
1390 TRANS_LOGI(TRANS_CTRL, "recv keepalive ack myChannelId=%{public}d, peerChannelId=%{public}d", msg->msgHead.myId,
1391 msg->msgHead.peerId);
1392 if (TransProxyUnpackIdentity(msg->data, info->identity, sizeof(info->identity), msg->dateLen) != SOFTBUS_OK) {
1393 SoftBusFree(info);
1394 return;
1395 }
1396 info->peerId = msg->msgHead.peerId;
1397 info->myId = msg->msgHead.myId;
1398
1399 if (TransProxyKeepAliveChan(info) != SOFTBUS_OK) {
1400 TRANS_LOGE(TRANS_CTRL, "reset keep alive ack proc fail myChannelId=%{public}d, peerChannelId=%{public}d",
1401 msg->msgHead.myId, msg->msgHead.peerId);
1402 SoftBusFree(info);
1403 return;
1404 }
1405 (void)memset_s(info->appInfo.sessionKey, sizeof(info->appInfo.sessionKey), 0, sizeof(info->appInfo.sessionKey));
1406 SoftBusFree(info);
1407 }
1408
TransProxyProcessDataRecv(const ProxyMessage * msg)1409 void TransProxyProcessDataRecv(const ProxyMessage *msg)
1410 {
1411 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1412 if (info == NULL) {
1413 TRANS_LOGE(TRANS_CTRL, "ProxyProcessDataRecv calloc failed.");
1414 return;
1415 }
1416
1417 if (TransProxyGetRecvMsgChanInfo(msg->msgHead.myId, msg->msgHead.peerId, info) != SOFTBUS_OK) {
1418 TRANS_LOGE(TRANS_CTRL, "data recv get info fail myChannelId=%{public}d, peerChannelId=%{public}d",
1419 msg->msgHead.myId, msg->msgHead.peerId);
1420 SoftBusFree(info);
1421 return;
1422 }
1423
1424 OnProxyChannelMsgReceived(info->channelId, &(info->appInfo), msg->data, msg->dateLen);
1425 (void)memset_s(info->appInfo.sessionKey, sizeof(info->appInfo.sessionKey), 0, sizeof(info->appInfo.sessionKey));
1426 SoftBusFree(info);
1427 }
1428
TransProxyOnMessageReceived(const ProxyMessage * msg)1429 void TransProxyOnMessageReceived(const ProxyMessage *msg)
1430 {
1431 if (msg == NULL) {
1432 return;
1433 }
1434 switch (msg->msgHead.type) {
1435 case PROXYCHANNEL_MSG_TYPE_HANDSHAKE: {
1436 TransProxyProcessHandshakeMsg(msg);
1437 break;
1438 }
1439 case PROXYCHANNEL_MSG_TYPE_HANDSHAKE_ACK: {
1440 TransProxyProcessHandshakeAckMsg(msg);
1441 break;
1442 }
1443 case PROXYCHANNEL_MSG_TYPE_RESET: {
1444 TransProxyProcessResetMsg(msg);
1445 break;
1446 }
1447 case PROXYCHANNEL_MSG_TYPE_KEEPALIVE: {
1448 TransProxyProcessKeepAlive(msg);
1449 break;
1450 }
1451 case PROXYCHANNEL_MSG_TYPE_KEEPALIVE_ACK: {
1452 TransProxyProcessKeepAliveAck(msg);
1453 break;
1454 }
1455 case PROXYCHANNEL_MSG_TYPE_NORMAL: {
1456 TransProxyProcessDataRecv(msg);
1457 break;
1458 }
1459 case PROXYCHANNEL_MSG_TYPE_HANDSHAKE_AUTH: {
1460 TransProxyProcessHandshakeAuthMsg(msg);
1461 break;
1462 }
1463 default: {
1464 break;
1465 }
1466 }
1467 }
1468
CopyAppInfoFastTransData(ProxyChannelInfo * chan,const AppInfo * appInfo)1469 static int32_t CopyAppInfoFastTransData(ProxyChannelInfo *chan, const AppInfo *appInfo)
1470 {
1471 if (appInfo->fastTransData != NULL && appInfo->fastTransDataSize > 0) {
1472 uint8_t *fastTransData = (uint8_t *)SoftBusCalloc(appInfo->fastTransDataSize);
1473 if (fastTransData == NULL) {
1474 return SOFTBUS_MALLOC_ERR;
1475 }
1476 if (memcpy_s((char *)fastTransData, appInfo->fastTransDataSize, (const char *)appInfo->fastTransData,
1477 appInfo->fastTransDataSize) != EOK) {
1478 TRANS_LOGE(TRANS_CTRL, "memcpy fastTransData fail");
1479 SoftBusFree(fastTransData);
1480 return SOFTBUS_MEM_ERR;
1481 }
1482 chan->appInfo.fastTransData = fastTransData;
1483 }
1484 return SOFTBUS_OK;
1485 }
1486
TransProxyCreateChanInfo(ProxyChannelInfo * chan,int32_t channelId,const AppInfo * appInfo)1487 int32_t TransProxyCreateChanInfo(ProxyChannelInfo *chan, int32_t channelId, const AppInfo *appInfo)
1488 {
1489 chan->myId = (int16_t)channelId;
1490 chan->channelId = channelId;
1491
1492 int32_t ret = GenerateRandomStr(chan->identity, sizeof(chan->identity));
1493 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "GenerateRandomStr err");
1494
1495 if (appInfo->appType != APP_TYPE_AUTH) {
1496 ret = SoftBusGenerateRandomArray((unsigned char *)appInfo->sessionKey, sizeof(appInfo->sessionKey));
1497 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "GenerateRandomArray err");
1498 }
1499
1500 if (memcpy_s(&(chan->appInfo), sizeof(chan->appInfo), appInfo, sizeof(AppInfo)) != EOK) {
1501 TRANS_LOGE(TRANS_CTRL, "appInfo memcpy failed.");
1502 return SOFTBUS_MEM_ERR;
1503 }
1504
1505 ret = CopyAppInfoFastTransData(chan, appInfo);
1506 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "copy appinfo fast trans data fail");
1507
1508 ret = TransProxyAddChanItem(chan);
1509 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
1510 TRANS_CTRL, "trans proxy add channelId fail. channelId=%{public}d", channelId);
1511 return SOFTBUS_OK;
1512 }
1513
TransProxyNegoSessionKeySucc(int32_t channelId)1514 void TransProxyNegoSessionKeySucc(int32_t channelId)
1515 {
1516 ProxyChannelInfo *channelInfo = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1517 TRANS_CHECK_AND_RETURN_LOGE(channelInfo != NULL, TRANS_CTRL, "malloc proxyChannelInfo failed");
1518
1519 if (TransProxyGetChanByChanId(channelId, channelInfo) != SOFTBUS_OK) {
1520 SoftBusFree(channelInfo);
1521 TRANS_LOGE(TRANS_CTRL, "disconnect device channelId=%{public}d", channelId);
1522 return;
1523 }
1524
1525 channelInfo->appInfo.connectedStart = GetSoftbusRecordTimeMillis();
1526 int32_t ret = TransProxyHandshake(channelInfo);
1527 if (ret != SOFTBUS_OK) {
1528 TransEventExtra extra = {
1529 .socketName = NULL,
1530 .peerNetworkId = NULL,
1531 .calleePkg = NULL,
1532 .callerPkg = NULL,
1533 .channelId = channelId,
1534 .connectionId = channelInfo->connId,
1535 .errcode = ret,
1536 .result = EVENT_STAGE_RESULT_FAILED
1537 };
1538 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_HANDSHAKE_START, extra);
1539 (void)TransProxyCloseConnChannel(channelInfo->connId, channelInfo->isServer);
1540 TRANS_LOGE(TRANS_CTRL, "channelId=%{public}d handshake err, ret=%{public}d", channelId, ret);
1541 TransProxyOpenProxyChannelFail(channelInfo->channelId, &(channelInfo->appInfo), ret);
1542 TransProxyDelChanByChanId(channelId);
1543 }
1544 (void)memset_s(channelInfo->appInfo.sessionKey, sizeof(channelInfo->appInfo.sessionKey), 0,
1545 sizeof(channelInfo->appInfo.sessionKey));
1546 SoftBusFree(channelInfo);
1547 }
1548
TransProxyNegoSessionKeyFail(int32_t channelId,int32_t errCode)1549 void TransProxyNegoSessionKeyFail(int32_t channelId, int32_t errCode)
1550 {
1551 ProxyChannelInfo *channelInfo = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1552 TRANS_CHECK_AND_RETURN_LOGE(channelInfo != NULL, TRANS_CTRL, "malloc proxyChannelInfo failed");
1553
1554 if (TransProxyGetChanByChanId(channelId, channelInfo) != SOFTBUS_OK) {
1555 SoftBusFree(channelInfo);
1556 TRANS_LOGE(TRANS_CTRL, "disconnect device channelId=%{public}d", channelId);
1557 return;
1558 }
1559
1560 (void)OnProxyChannelOpenFailed(channelId, &(channelInfo->appInfo), errCode);
1561 (void)memset_s(channelInfo->appInfo.sessionKey, sizeof(channelInfo->appInfo.sessionKey), 0,
1562 sizeof(channelInfo->appInfo.sessionKey));
1563 SoftBusFree(channelInfo);
1564 TransProxyDelChanByChanId(channelId);
1565 }
1566
TransProxyOpenProxyChannelSuccess(int32_t channelId)1567 void TransProxyOpenProxyChannelSuccess(int32_t channelId)
1568 {
1569 TRANS_LOGI(TRANS_CTRL, "send handshake msg. channelId=%{public}d", channelId);
1570 ProxyChannelInfo *channelInfo = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1571 TRANS_CHECK_AND_RETURN_LOGE(channelInfo != NULL, TRANS_CTRL, "malloc proxyChannelInfo failed");
1572
1573 if (TransProxyGetChanByChanId(channelId, channelInfo) != SOFTBUS_OK) {
1574 SoftBusFree(channelInfo);
1575 TRANS_LOGE(TRANS_CTRL, "disconnect device channelId=%{public}d", channelId);
1576 return;
1577 }
1578 (void)memset_s(channelInfo->appInfo.sessionKey, sizeof(channelInfo->appInfo.sessionKey), 0,
1579 sizeof(channelInfo->appInfo.sessionKey));
1580 AuthConnInfo authConnInfo;
1581 (void)memset_s(&authConnInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
1582 int32_t ret = GetAuthConnInfoByConnId(channelInfo->connId, &authConnInfo);
1583 if (ret != SOFTBUS_OK) {
1584 TRANS_LOGE(TRANS_CTRL, "get authConnInfo by connId=%{public}u fail, ret=%{public}d", channelInfo->connId, ret);
1585 SoftBusFree(channelInfo);
1586 return;
1587 }
1588
1589 char peerNetworkId[DEVICE_ID_SIZE_MAX] = { 0 };
1590 ret = TransGetRemoteDeviceIdByReqId(channelInfo->reqId, peerNetworkId);
1591 SoftBusFree(channelInfo);
1592 if (ret != SOFTBUS_OK) {
1593 TRANS_LOGE(TRANS_CTRL, "get networkId failed, ret=%{public}d", ret);
1594 return;
1595 }
1596
1597 ret = TransNegotiateSessionKey(&authConnInfo, channelId, peerNetworkId);
1598 if (ret != SOFTBUS_OK) {
1599 TransProxyNegoSessionKeyFail(channelId, ret);
1600 TRANS_LOGE(TRANS_CTRL, "generate session key failed ret=%{public}d", ret);
1601 return;
1602 }
1603 }
1604
TransProxyOpenProxyChannelFail(int32_t channelId,const AppInfo * appInfo,int32_t errCode)1605 void TransProxyOpenProxyChannelFail(int32_t channelId, const AppInfo *appInfo, int32_t errCode)
1606 {
1607 (void)OnProxyChannelOpenFailed(channelId, appInfo, errCode);
1608 }
1609
TransProxyOpenProxyChannel(AppInfo * appInfo,const ConnectOption * connInfo,int32_t * channelId)1610 int32_t TransProxyOpenProxyChannel(AppInfo *appInfo, const ConnectOption *connInfo,
1611 int32_t *channelId)
1612 {
1613 if (appInfo == NULL || connInfo == NULL || channelId == NULL) {
1614 TRANS_LOGE(TRANS_CTRL, "open normal channel: invalid para");
1615 return SOFTBUS_INVALID_PARAM;
1616 }
1617
1618 SelectRouteType(connInfo->type, &appInfo->routeType);
1619 return TransProxyOpenConnChannel(appInfo, connInfo, channelId);
1620 }
1621
TransProxyCloseProxyChannel(int32_t channelId)1622 int32_t TransProxyCloseProxyChannel(int32_t channelId)
1623 {
1624 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1625 if (info == NULL) {
1626 return SOFTBUS_MALLOC_ERR;
1627 }
1628
1629 if (TransProxyDelByChannelId(channelId, info) != SOFTBUS_OK) {
1630 TRANS_LOGE(TRANS_CTRL, "proxy del failed. channelId=%{public}d", channelId);
1631 SoftBusFree(info);
1632 return SOFTBUS_TRANS_PROXY_INVALID_CHANNEL_ID;
1633 }
1634
1635 (void)memset_s(info->appInfo.sessionKey, sizeof(info->appInfo.sessionKey), 0, sizeof(info->appInfo.sessionKey));
1636 TransProxyCloseProxyOtherRes(channelId, info);
1637 return SOFTBUS_OK;
1638 }
1639
TransProxyTimerItemProc(const ListNode * proxyProcList)1640 static void TransProxyTimerItemProc(const ListNode *proxyProcList)
1641 {
1642 if (IsListEmpty(proxyProcList)) {
1643 return;
1644 }
1645 TRANS_LOGI(TRANS_CTRL, "enter.");
1646 ProxyChannelInfo *removeNode = NULL;
1647 ProxyChannelInfo *nextNode = NULL;
1648 ProxyChannelInfo *disChanInfo = NULL;
1649 uint32_t connId;
1650 int8_t status;
1651 bool isServer;
1652
1653 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, proxyProcList, ProxyChannelInfo, node) {
1654 ListDelete(&(removeNode->node));
1655 status = removeNode->status;
1656 SoftBusFree((void *)removeNode->appInfo.fastTransData);
1657 removeNode->appInfo.fastTransData = NULL;
1658 (void)memset_s(removeNode->appInfo.sessionKey, sizeof(removeNode->appInfo.sessionKey), 0,
1659 sizeof(removeNode->appInfo.sessionKey));
1660 if (status == PROXY_CHANNEL_STATUS_HANDSHAKE_TIMEOUT) {
1661 connId = removeNode->connId;
1662 isServer = removeNode->isServer;
1663 disChanInfo = (ProxyChannelInfo *)SoftBusMalloc(sizeof(ProxyChannelInfo));
1664 if (disChanInfo == NULL) {
1665 SoftBusFree(removeNode);
1666 TRANS_LOGE(TRANS_SVC, "SoftBusMalloc failed");
1667 return;
1668 }
1669 if (memcpy_s(disChanInfo, sizeof(ProxyChannelInfo), removeNode, sizeof(ProxyChannelInfo)) != EOK) {
1670 SoftBusFree(removeNode);
1671 SoftBusFree(disChanInfo);
1672 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
1673 return;
1674 }
1675 TransProxyPostOpenFailMsgToLoop(removeNode, SOFTBUS_TRANS_HANDSHAKE_TIMEOUT);
1676 TransProxyPostDisConnectMsgToLoop(connId, isServer, disChanInfo);
1677 } else if (status == PROXY_CHANNEL_STATUS_CONNECTING_TIMEOUT) {
1678 (void)TransDelConnByReqId(removeNode->reqId);
1679 TransProxyPostOpenFailMsgToLoop(removeNode, SOFTBUS_TRANS_HANDSHAKE_TIMEOUT);
1680 } else if (status == PROXY_CHANNEL_STATUS_TIMEOUT) {
1681 TRANS_LOGI(TRANS_CTRL, "send keepalive channelId=%{public}d", removeNode->myId);
1682 TransProxyPostKeepAliveMsgToLoop(removeNode);
1683 } else {
1684 SoftBusFree(removeNode);
1685 }
1686 }
1687 }
1688
TransProxyTimerProc(void)1689 void TransProxyTimerProc(void)
1690 {
1691 ProxyChannelInfo *removeNode = NULL;
1692 ProxyChannelInfo *nextNode = NULL;
1693 ListNode proxyProcList;
1694
1695 TRANS_CHECK_AND_RETURN_LOGE(
1696 g_proxyChannelList != NULL, TRANS_CTRL, "g_proxyChannelList is null");
1697 TRANS_CHECK_AND_RETURN_LOGE(
1698 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, TRANS_CTRL, "lock mutex fail!");
1699 if (g_proxyChannelList->cnt <= 0) {
1700 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1701 return;
1702 }
1703
1704 ListInit(&proxyProcList);
1705 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
1706 removeNode->timeout++;
1707 if (removeNode->status == PROXY_CHANNEL_STATUS_HANDSHAKEING ||
1708 removeNode->status == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
1709 if (removeNode->timeout >= PROXY_CHANNEL_CONTROL_TIMEOUT) {
1710 removeNode->status = (removeNode->status == PROXY_CHANNEL_STATUS_HANDSHAKEING) ?
1711 PROXY_CHANNEL_STATUS_HANDSHAKE_TIMEOUT : PROXY_CHANNEL_STATUS_CONNECTING_TIMEOUT;
1712 TRANS_LOGE(TRANS_CTRL, "handshake is timeout. channelId=%{public}d", removeNode->myId);
1713 ReleaseProxyChannelId(removeNode->channelId);
1714 ListDelete(&(removeNode->node));
1715 ListAdd(&proxyProcList, &(removeNode->node));
1716 g_proxyChannelList->cnt--;
1717 }
1718 }
1719 if (removeNode->status == PROXY_CHANNEL_STATUS_KEEPLIVEING) {
1720 if (removeNode->timeout >= PROXY_CHANNEL_CONTROL_TIMEOUT) {
1721 removeNode->status = PROXY_CHANNEL_STATUS_TIMEOUT;
1722 TRANS_LOGE(TRANS_CTRL, "keepalvie is timeout. channelId=%{public}d", removeNode->myId);
1723 ReleaseProxyChannelId(removeNode->channelId);
1724 ListDelete(&(removeNode->node));
1725 ListAdd(&proxyProcList, &(removeNode->node));
1726 g_proxyChannelList->cnt--;
1727 }
1728 }
1729 }
1730 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1731 TransProxyTimerItemProc(&proxyProcList);
1732 }
1733
TransWifiOnLineProc(const char * peerNetworkId)1734 static void TransWifiOnLineProc(const char *peerNetworkId)
1735 {
1736 TRANS_LOGI(TRANS_CTRL, "wifi is online");
1737 if (peerNetworkId == NULL) {
1738 TRANS_LOGE(TRANS_CTRL, "invalid networkId");
1739 return;
1740 }
1741 int ret = NotifyNearByOnMigrateEvents(peerNetworkId, WIFI_STA, true);
1742 if (ret == SOFTBUS_OK) {
1743 TRANS_LOGI(TRANS_CTRL, "notify upgrade migrate success");
1744 return;
1745 }
1746 TRANS_LOGE(TRANS_CTRL, "notify upgrade migrate fail");
1747 }
1748
TransWifiOffLineProc(const char * peerNetworkId)1749 static void TransWifiOffLineProc(const char *peerNetworkId)
1750 {
1751 TRANS_LOGI(TRANS_CTRL, "wifi is offline");
1752 if (peerNetworkId == NULL) {
1753 TRANS_LOGE(TRANS_CTRL, "invalid networkId");
1754 return;
1755 }
1756 int ret = NotifyNearByOnMigrateEvents(peerNetworkId, WIFI_STA, false);
1757 if (ret == SOFTBUS_OK) {
1758 TRANS_LOGI(TRANS_CTRL, "notify degrade migrate success");
1759 return;
1760 }
1761 TRANS_LOGE(TRANS_CTRL, "notify degrade migrate fail");
1762 }
1763
TransWifiStateChange(const LnnEventBasicInfo * info)1764 void TransWifiStateChange(const LnnEventBasicInfo *info)
1765 {
1766 TRANS_LOGI(TRANS_CTRL, "Start");
1767 if ((info == NULL) || (info->event != LNN_EVENT_NODE_MIGRATE)) {
1768 return;
1769 }
1770
1771 LnnOnlineStateEventInfo *onlineStateInfo = (LnnOnlineStateEventInfo *)info;
1772 if (onlineStateInfo->isOnline == true) {
1773 TransWifiOnLineProc(onlineStateInfo->networkId);
1774 } else {
1775 TransWifiOffLineProc(onlineStateInfo->networkId);
1776 }
1777 }
1778
TransNotifySingleNetworkOffLine(const LnnEventBasicInfo * info)1779 static void TransNotifySingleNetworkOffLine(const LnnEventBasicInfo *info)
1780 {
1781 if ((info == NULL) || (info->event != LNN_EVENT_SINGLE_NETWORK_OFFLINE)) {
1782 return;
1783 }
1784 LnnSingleNetworkOffLineEvent *offlineInfo = (LnnSingleNetworkOffLineEvent *)info;
1785 ConnectionAddrType type = offlineInfo->type;
1786 if (type == CONNECTION_ADDR_WLAN) {
1787 TransOnLinkDown(offlineInfo->networkId, offlineInfo->uuid, offlineInfo->udid, "", WIFI_STA);
1788 } else if (type == CONNECTION_ADDR_BLE) {
1789 TransOnLinkDown(offlineInfo->networkId, offlineInfo->uuid, offlineInfo->udid, "", BT_BLE);
1790 } else if (type == CONNECTION_ADDR_BR) {
1791 TransOnLinkDown(offlineInfo->networkId, offlineInfo->uuid, offlineInfo->udid, "", BT_BR);
1792 }
1793 }
1794
TransNotifyOffLine(const LnnEventBasicInfo * info)1795 static void TransNotifyOffLine(const LnnEventBasicInfo *info)
1796 {
1797 TRANS_LOGI(TRANS_CTRL, "Trans Notify OffLine Start");
1798 if ((info == NULL) || (info->event != LNN_EVENT_NODE_ONLINE_STATE_CHANGED)) {
1799 return;
1800 }
1801 LnnOnlineStateEventInfo *onlineStateInfo = (LnnOnlineStateEventInfo *)info;
1802 if (onlineStateInfo->isOnline) {
1803 return;
1804 }
1805
1806 TransOnLinkDown(onlineStateInfo->networkId, onlineStateInfo->uuid, onlineStateInfo->udid, "", WIFI_P2P);
1807 TransOnLinkDown(onlineStateInfo->networkId, onlineStateInfo->uuid, onlineStateInfo->udid, "", WIFI_STA);
1808 TransOnLinkDown(onlineStateInfo->networkId, onlineStateInfo->uuid, onlineStateInfo->udid, "", BT_BR);
1809 TransOnLinkDown(onlineStateInfo->networkId, onlineStateInfo->uuid, onlineStateInfo->udid, "", BT_BLE);
1810 }
1811
TransProxyManagerInitInner(const IServerChannelCallBack * cb)1812 static int32_t TransProxyManagerInitInner(const IServerChannelCallBack *cb)
1813 {
1814 int32_t ret = TransProxySetCallBack(cb);
1815 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "TransProxySetCallBack fail");
1816
1817 g_proxyChannelList = CreateSoftBusList();
1818 if (g_proxyChannelList == NULL) {
1819 TRANS_LOGE(TRANS_INIT, "proxy manager init inner failed");
1820 return SOFTBUS_MALLOC_ERR;
1821 }
1822 return SOFTBUS_OK;
1823 }
1824
TransProxyManagerInit(const IServerChannelCallBack * cb)1825 int32_t TransProxyManagerInit(const IServerChannelCallBack *cb)
1826 {
1827 int32_t ret = TransProxyManagerInitInner(cb);
1828 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "init proxy manager failed");
1829
1830 ret = TransProxyTransInit();
1831 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "TransProxyTransInit fail");
1832
1833 ret = RegisterTimeoutCallback(SOFTBUS_PROXYCHANNEL_TIMER_FUN, TransProxyTimerProc);
1834 if (ret != SOFTBUS_OK) {
1835 DestroySoftBusList(g_proxyChannelList);
1836 TRANS_LOGE(TRANS_INIT, "trans proxy register timeout callback failed.");
1837 return ret;
1838 }
1839
1840 ret = LnnRegisterEventHandler(LNN_EVENT_SINGLE_NETWORK_OFFLINE, TransNotifySingleNetworkOffLine);
1841 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
1842 TRANS_INIT, "register TransNotifySingleNetworkOffLine failed.");
1843
1844 ret = LnnRegisterEventHandler(LNN_EVENT_NODE_ONLINE_STATE_CHANGED, TransNotifyOffLine);
1845 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "register TransNotifyOffLine failed.");
1846
1847 ret = LnnRegisterEventHandler(LNN_EVENT_NODE_MIGRATE, TransWifiStateChange);
1848 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "TransWifiStateChange register fail");
1849
1850 TRANS_LOGI(TRANS_INIT, "proxy channel init ok");
1851 return SOFTBUS_OK;
1852 }
1853
TransProxyGetNameByChanId(int32_t chanId,char * pkgName,char * sessionName,uint16_t pkgLen,uint16_t sessionLen)1854 int32_t TransProxyGetNameByChanId(int32_t chanId, char *pkgName, char *sessionName,
1855 uint16_t pkgLen, uint16_t sessionLen)
1856 {
1857 TRANS_CHECK_AND_RETURN_RET_LOGE((pkgName != NULL && sessionName != NULL), SOFTBUS_INVALID_PARAM, TRANS_CTRL,
1858 "invalid param");
1859 ProxyChannelInfo *chan = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1860 TRANS_CHECK_AND_RETURN_RET_LOGE(chan != NULL, SOFTBUS_MALLOC_ERR, TRANS_CTRL, "malloc err");
1861 int32_t ret = TransProxyGetChanByChanId(chanId, chan);
1862 (void)memset_s(chan->appInfo.sessionKey, sizeof(chan->appInfo.sessionKey), 0, sizeof(chan->appInfo.sessionKey));
1863 if (ret != SOFTBUS_OK) {
1864 TRANS_LOGE(TRANS_CTRL, "get channel info by chanId failed. chanId=%{public}d", chanId);
1865 SoftBusFree(chan);
1866 return ret;
1867 }
1868 ret = TransProxyGetPkgName(chan->appInfo.myData.sessionName, pkgName, pkgLen);
1869 if (ret != SOFTBUS_OK) {
1870 TRANS_LOGE(TRANS_CTRL, "get pkgName failed");
1871 SoftBusFree(chan);
1872 return ret;
1873 }
1874 if (strcpy_s(sessionName, sessionLen, chan->appInfo.myData.sessionName) != EOK) {
1875 TRANS_LOGE(TRANS_CTRL, "strcpy_s failed");
1876 SoftBusFree(chan);
1877 return SOFTBUS_STRCPY_ERR;
1878 }
1879 SoftBusFree(chan);
1880 return SOFTBUS_OK;
1881 }
1882
TransProxyManagerDeinitInner(void)1883 static void TransProxyManagerDeinitInner(void)
1884 {
1885 TRANS_CHECK_AND_RETURN_LOGE(
1886 g_proxyChannelList != NULL, TRANS_INIT, "g_proxyChannelList is null");
1887 TRANS_CHECK_AND_RETURN_LOGE(
1888 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, TRANS_INIT, "lock mutex fail!");
1889 ProxyChannelInfo *item = NULL;
1890 ProxyChannelInfo *nextNode = NULL;
1891 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
1892 ReleaseProxyChannelId(item->channelId);
1893 ListDelete(&(item->node));
1894 if (item->appInfo.fastTransData != NULL) {
1895 SoftBusFree((void *)item->appInfo.fastTransData);
1896 }
1897 SoftBusFree(item);
1898 }
1899 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1900
1901 DestroySoftBusList(g_proxyChannelList);
1902 }
1903
TransProxyManagerDeinit(void)1904 void TransProxyManagerDeinit(void)
1905 {
1906 TransProxyManagerDeinitInner();
1907
1908 (void)RegisterTimeoutCallback(SOFTBUS_PROXYCHANNEL_TIMER_FUN, NULL);
1909 }
1910
TransProxyDestroyChannelList(const ListNode * destroyList)1911 static void TransProxyDestroyChannelList(const ListNode *destroyList)
1912 {
1913 TRANS_LOGD(TRANS_CTRL, "enter.");
1914 TRANS_CHECK_AND_RETURN_LOGE(
1915 (destroyList != NULL && !IsListEmpty(destroyList)), TRANS_INIT, "destroyList is null");
1916 ProxyChannelInfo *destroyNode = NULL;
1917 ProxyChannelInfo *nextDestroyNode = NULL;
1918 LIST_FOR_EACH_ENTRY_SAFE(destroyNode, nextDestroyNode, destroyList, ProxyChannelInfo, node) {
1919 ListDelete(&(destroyNode->node));
1920 TransProxyResetPeer(destroyNode);
1921 TransProxyCloseConnChannel(destroyNode->connId, destroyNode->isServer);
1922 if (destroyNode->appInfo.fastTransData != NULL) {
1923 SoftBusFree((void *)destroyNode->appInfo.fastTransData);
1924 }
1925 (void)memset_s(destroyNode->appInfo.sessionKey, sizeof(destroyNode->appInfo.sessionKey), 0,
1926 sizeof(destroyNode->appInfo.sessionKey));
1927 SoftBusFree(destroyNode);
1928 }
1929 return;
1930 }
1931
TransProxyDeathCallback(const char * pkgName,int32_t pid)1932 void TransProxyDeathCallback(const char *pkgName, int32_t pid)
1933 {
1934 TRANS_CHECK_AND_RETURN_LOGE(
1935 (pkgName != NULL && g_proxyChannelList != NULL), TRANS_CTRL, "pkgName or proxy channel list is null.");
1936 char *anonymizePkgName = NULL;
1937 Anonymize(pkgName, &anonymizePkgName);
1938 TRANS_LOGW(TRANS_CTRL, "pkgName=%{public}s, pid=%{public}d", anonymizePkgName, pid);
1939 AnonymizeFree(anonymizePkgName);
1940 ListNode destroyList;
1941 ListInit(&destroyList);
1942 ProxyChannelInfo *item = NULL;
1943 ProxyChannelInfo *nextNode = NULL;
1944 if (SoftBusMutexLock(&g_proxyChannelList->lock) != SOFTBUS_OK) {
1945 TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
1946 return;
1947 }
1948 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
1949 if ((strcmp(item->appInfo.myData.pkgName, pkgName) == 0) && (item->appInfo.myData.pid == pid)) {
1950 ReleaseProxyChannelId(item->channelId);
1951 ListDelete(&(item->node));
1952 g_proxyChannelList->cnt--;
1953 ListAdd(&destroyList, &(item->node));
1954 TRANS_LOGI(TRANS_CTRL, "add channelId=%{public}d", item->channelId);
1955 }
1956 }
1957 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1958 TransProxyDestroyChannelList(&destroyList);
1959 TRANS_LOGD(TRANS_CTRL, "ok");
1960 }
1961
TransProxyGetAppInfoByChanId(int32_t chanId,AppInfo * appInfo)1962 int32_t TransProxyGetAppInfoByChanId(int32_t chanId, AppInfo *appInfo)
1963 {
1964 TRANS_CHECK_AND_RETURN_RET_LOGE(appInfo != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL,
1965 "invalid param");
1966
1967 ProxyChannelInfo *item = NULL;
1968 ProxyChannelInfo *nextNode = NULL;
1969
1970 TRANS_CHECK_AND_RETURN_RET_LOGE(
1971 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
1972 TRANS_CHECK_AND_RETURN_RET_LOGE(
1973 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
1974
1975 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
1976 if (item->channelId == chanId) {
1977 if (memcpy_s(appInfo, sizeof(AppInfo), &item->appInfo, sizeof(AppInfo)) != EOK) {
1978 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1979 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
1980 return SOFTBUS_MEM_ERR;
1981 }
1982 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1983 return SOFTBUS_OK;
1984 }
1985 }
1986 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1987 TRANS_LOGE(TRANS_CTRL, "Proxy channel not find: channelId=%{public}d", chanId);
1988 return SOFTBUS_TRANS_NODE_NOT_FOUND;
1989 }
1990
TransProxyGetConnIdByChanId(int32_t channelId,int32_t * connId)1991 int32_t TransProxyGetConnIdByChanId(int32_t channelId, int32_t *connId)
1992 {
1993 TRANS_CHECK_AND_RETURN_RET_LOGE(connId != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL,
1994 "invalid param");
1995
1996 ProxyChannelInfo *item = NULL;
1997
1998 TRANS_CHECK_AND_RETURN_RET_LOGE(
1999 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
2000 TRANS_CHECK_AND_RETURN_RET_LOGE(
2001 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
2002
2003 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
2004 if (item->channelId == channelId) {
2005 if (item->status == PROXY_CHANNEL_STATUS_COMPLETED ||
2006 item->status == PROXY_CHANNEL_STATUS_KEEPLIVEING) {
2007 *connId = (int32_t)item->connId;
2008 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2009 return SOFTBUS_OK;
2010 } else {
2011 TRANS_LOGE(TRANS_CTRL, "g_proxyChannel status error");
2012 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2013 return SOFTBUS_TRANS_PROXY_CHANNLE_STATUS_INVALID;
2014 }
2015 }
2016 }
2017 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2018 return SOFTBUS_TRANS_NODE_NOT_FOUND;
2019 }
2020
TransProxyGetProxyChannelInfoByChannelId(int32_t channelId,ProxyChannelInfo * chan)2021 static int32_t TransProxyGetProxyChannelInfoByChannelId(int32_t channelId, ProxyChannelInfo *chan)
2022 {
2023 if (g_proxyChannelList == NULL) {
2024 TRANS_LOGE(TRANS_CTRL, "g_proxyChannelList is null");
2025 return SOFTBUS_INVALID_PARAM;
2026 }
2027 if (SoftBusMutexLock(&g_proxyChannelList->lock) != SOFTBUS_OK) {
2028 TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
2029 return SOFTBUS_LOCK_ERR;
2030 }
2031 ProxyChannelInfo *item = NULL;
2032 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
2033 if (item->channelId == channelId) {
2034 if (item->status != PROXY_CHANNEL_STATUS_COMPLETED && item->status != PROXY_CHANNEL_STATUS_KEEPLIVEING) {
2035 TRANS_LOGE(TRANS_CTRL, "invalid status=%{public}d, channelId=%{public}d", item->status, channelId);
2036 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2037 return SOFTBUS_TRANS_PROXY_CHANNLE_STATUS_INVALID;
2038 }
2039 if (memcpy_s(chan, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo)) != EOK) {
2040 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2041 TRANS_LOGE(TRANS_CTRL, "memcpy_s failed");
2042 return SOFTBUS_MEM_ERR;
2043 }
2044 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2045 return SOFTBUS_OK;
2046 }
2047 }
2048 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2049 TRANS_LOGE(TRANS_CTRL, "not found proxy channel info by channelId=%{public}d", channelId);
2050 return SOFTBUS_TRANS_NODE_NOT_FOUND;
2051 }
2052
TransProxyUdpateNewPeerUdidHash(const char * deviceId,ConnectOption * connOpt)2053 static int32_t TransProxyUdpateNewPeerUdidHash(const char *deviceId, ConnectOption *connOpt)
2054 {
2055 uint8_t udidHash[UDID_HASH_LEN] = { 0 };
2056 int32_t ret = SoftBusGenerateStrHash((const unsigned char *)deviceId, strlen(deviceId), udidHash);
2057 if (ret != SOFTBUS_OK) {
2058 TRANS_LOGE(TRANS_CTRL, "Generate UDID HexStringHash fail, ret=%{public}d", ret);
2059 return ret;
2060 }
2061 if (memcpy_s(connOpt->bleOption.deviceIdHash, UDID_HASH_LEN, udidHash, UDID_HASH_LEN) != EOK) {
2062 TRANS_LOGE(TRANS_CTRL, "memcpy_s udid hash err");
2063 return SOFTBUS_MEM_ERR;
2064 }
2065 return SOFTBUS_OK;
2066 }
2067
TransProxyGetConnOptionByChanId(int32_t channelId,ConnectOption * connOpt)2068 int32_t TransProxyGetConnOptionByChanId(int32_t channelId, ConnectOption *connOpt)
2069 {
2070 TRANS_CHECK_AND_RETURN_RET_LOGE(connOpt != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL, "invalid param");
2071 ProxyChannelInfo chan;
2072 (void)memset_s(&chan, sizeof(ProxyChannelInfo), 0, sizeof(ProxyChannelInfo));
2073 int32_t ret = TransProxyGetProxyChannelInfoByChannelId(channelId, &chan);
2074 if (ret != SOFTBUS_OK) {
2075 TRANS_LOGE(TRANS_CTRL, "get proxy channel info fail, channelId=%{public}d, ret=%{public}d", channelId, ret);
2076 return ret;
2077 }
2078
2079 ret = TransProxyGetConnInfoByConnId(chan.connId, connOpt);
2080 if (ret != SOFTBUS_OK) {
2081 TRANS_LOGE(TRANS_CTRL, "get conn optinfo fail, channelId=%{public}d, connId=%{public}d, ret=%{public}d",
2082 chan.channelId, chan.connId, ret);
2083 return ret;
2084 }
2085
2086 ret = TransProxyUdpateNewPeerUdidHash(chan.appInfo.peerData.deviceId, connOpt);
2087 if (ret != SOFTBUS_OK) {
2088 TRANS_LOGE(TRANS_CTRL, "get new peer udid hash fail, channelId=%{public}d, connId=%{public}d, ret=%{public}d",
2089 chan.channelId, chan.connId, ret);
2090 return ret;
2091 }
2092
2093 char udidHashStr[HEXIFY_LEN(SHORT_UDID_HASH_LEN)] = { 0 };
2094 ret = ConvertBytesToHexString(udidHashStr, HEXIFY_LEN(SHORT_UDID_HASH_LEN),
2095 (unsigned char *)connOpt->bleOption.deviceIdHash, SHORT_UDID_HASH_LEN);
2096 if (ret != SOFTBUS_OK) {
2097 TRANS_LOGE(
2098 TRANS_CTRL, "convert udid hash to string fail, channelId=%{public}d, connId=%{public}d, ret=%{public}d",
2099 chan.channelId, chan.connId, ret);
2100 return ret;
2101 }
2102
2103 char *udidHash = NULL;
2104 Anonymize(udidHashStr, &udidHash);
2105 TRANS_LOGI(TRANS_CTRL, "channelId=%{public}d, connId=%{public}d, udidHash=%{public}s",
2106 chan.channelId, chan.connId, AnonymizeWrapper(udidHash));
2107 AnonymizeFree(udidHash);
2108 return SOFTBUS_OK;
2109 }
2110
TransProxySetAuthHandleByChanId(int32_t channelId,AuthHandle authHandle)2111 int32_t TransProxySetAuthHandleByChanId(int32_t channelId, AuthHandle authHandle)
2112 {
2113 ProxyChannelInfo *item = NULL;
2114 ProxyChannelInfo *nextNode = NULL;
2115
2116 TRANS_CHECK_AND_RETURN_RET_LOGE(
2117 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
2118 TRANS_CHECK_AND_RETURN_RET_LOGE(
2119 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
2120
2121 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
2122 if (item->channelId == channelId) {
2123 item->authHandle.authId = authHandle.authId;
2124 item->authHandle.type = authHandle.type;
2125 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2126 return SOFTBUS_OK;
2127 }
2128 }
2129 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2130 TRANS_LOGE(TRANS_CTRL, "proxy channel not found by chanId, chanId=%{public}d", channelId);
2131 return SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND;
2132 }
2133