1 /*
2 * Copyright (c) 2021-2025 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_apply_key_process.h"
22 #include "auth_interface.h"
23 #include "auth_manager.h"
24 #include "auth_session_fsm.h"
25 #include "bus_center_event.h"
26 #include "bus_center_info_key.h"
27 #include "bus_center_manager.h"
28 #include "common_list.h"
29 #include "data_bus_native.h"
30 #include "g_enhance_trans_func_pack.h"
31 #include "legacy/softbus_adapter_hitrace.h"
32 #include "lnn_distributed_net_ledger.h"
33 #include "lnn_ohos_account_adapter.h"
34 #include "softbus_access_token_adapter.h"
35 #include "softbus_adapter_crypto.h"
36 #include "softbus_adapter_mem.h"
37 #include "softbus_adapter_thread.h"
38 #include "softbus_adapter_timer.h"
39 #include "softbus_conn_interface.h"
40 #include "softbus_def.h"
41 #include "softbus_feature_config.h"
42 #include "softbus_message_open_channel.h"
43 #include "softbus_proxychannel_callback.h"
44 #include "softbus_proxychannel_control.h"
45 #include "softbus_proxychannel_listener.h"
46 #include "softbus_proxychannel_message.h"
47 #include "softbus_proxychannel_session.h"
48 #include "softbus_proxychannel_transceiver.h"
49 #include "softbus_utils.h"
50 #include "trans_auth_negotiation.h"
51 #include "trans_bind_request_manager.h"
52 #include "trans_channel_common.h"
53 #include "trans_channel_limit.h"
54 #include "trans_channel_manager.h"
55 #include "trans_event.h"
56 #include "trans_inner.h"
57 #include "trans_log.h"
58 #include "trans_session_manager.h"
59 #include "trans_uk_manager.h"
60
61 #define ID_OFFSET (1)
62
63 #define D2D_CHANNEL_CONTROL_TIMEOUT 60 // 60s
64 #define PROXY_CHANNEL_CONTROL_TIMEOUT 19 // 19s
65 #define PROXY_CHANNEL_BT_IDLE_TIMEOUT 240 // 4min
66 #define PROXY_CHANNEL_IDLE_TIMEOUT 15 // 10800 = 3 hour
67 #define PROXY_CHANNEL_TCP_IDLE_TIMEOUT 43200 // tcp 24 hour
68 #define PROXY_CHANNEL_CLIENT 0
69 #define PROXY_CHANNEL_SERVER 1
70 static SoftBusList *g_proxyChannelList = NULL;
71
72 typedef struct {
73 int32_t channelType;
74 int32_t businessType;
75 ConfigType configType;
76 } ConfigTypeMap;
77
GetProxyChannelMgrHead(void)78 SoftBusList *GetProxyChannelMgrHead(void)
79 {
80 return g_proxyChannelList;
81 }
82
GetProxyChannelLock(void)83 int32_t GetProxyChannelLock(void)
84 {
85 if (g_proxyChannelList == NULL) {
86 return SOFTBUS_NO_INIT;
87 }
88 if (SoftBusMutexLock(&g_proxyChannelList->lock) != SOFTBUS_OK) {
89 TRANS_LOGE(TRANS_CTRL, "lock failed");
90 return SOFTBUS_LOCK_ERR;
91 }
92 return SOFTBUS_OK;
93 }
94
ReleaseProxyChannelLock(void)95 void ReleaseProxyChannelLock(void)
96 {
97 if (g_proxyChannelList == NULL) {
98 return;
99 }
100 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
101 }
102
ChanIsEqual(ProxyChannelInfo * a,ProxyChannelInfo * b)103 static bool ChanIsEqual(ProxyChannelInfo *a, ProxyChannelInfo *b)
104 {
105 if ((a->myId == b->myId) &&
106 (a->peerId == b->peerId) &&
107 (strncmp(a->identity, b->identity, sizeof(a->identity)) == 0)) {
108 return true;
109 }
110 return false;
111 }
112
ResetChanIsEqual(int8_t status,ProxyChannelInfo * a,ProxyChannelInfo * b)113 static bool ResetChanIsEqual(int8_t status, ProxyChannelInfo *a, ProxyChannelInfo *b)
114 {
115 if (status == PROXY_CHANNEL_STATUS_HANDSHAKEING) {
116 if ((a->myId == b->myId) &&
117 (strncmp(a->identity, b->identity, sizeof(a->identity)) == 0)) {
118 return true;
119 }
120 }
121
122 if ((a->myId == b->myId) &&
123 (a->peerId == b->peerId) &&
124 (strncmp(a->identity, b->identity, sizeof(a->identity)) == 0)) {
125 return true;
126 }
127 return false;
128 }
129
TransProxyGetAppInfoType(int16_t myId,const char * identity,AppType * appType)130 int32_t TransProxyGetAppInfoType(int16_t myId, const char *identity, AppType *appType)
131 {
132 TRANS_CHECK_AND_RETURN_RET_LOGE(
133 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "fail to lock mutex!");
134 ProxyChannelInfo *item = NULL;
135 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
136 if ((item->myId == myId) && (strcmp(item->identity, identity) == 0)) {
137 *appType = item->appInfo.appType;
138 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
139 return SOFTBUS_OK;
140 }
141 }
142 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
143 return SOFTBUS_TRANS_PROXY_ERROR_APP_TYPE;
144 }
145
TransPagingUpdatePagingChannelInfo(ProxyChannelInfo * info)146 int32_t TransPagingUpdatePagingChannelInfo(ProxyChannelInfo *info)
147 {
148 TRANS_CHECK_AND_RETURN_RET_LOGE((g_proxyChannelList != NULL && info != NULL), SOFTBUS_INVALID_PARAM, TRANS_CTRL,
149 "g_proxyChannelList or item is null");
150 TRANS_CHECK_AND_RETURN_RET_LOGE(
151 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
152 ProxyChannelInfo *item = NULL;
153 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
154 if (item->myId == (int16_t)info->appInfo.myData.channelId) {
155 item->peerId = (int16_t)info->appInfo.peerData.channelId;
156 item->status = PROXY_CHANNEL_STATUS_COMPLETED;
157 item->timeout = 0;
158 if (memcpy_s(item->appInfo.pagingSessionkey, SHORT_SESSION_KEY_LENGTH, info->appInfo.pagingSessionkey,
159 SHORT_SESSION_KEY_LENGTH) != EOK ||
160 memcpy_s(item->appInfo.pagingNonce, PAGING_NONCE_LEN,
161 info->appInfo.pagingNonce, PAGING_NONCE_LEN) != EOK ||
162 memcpy_s(info->appInfo.peerData.shortAccountHash, D2D_SHORT_ACCOUNT_HASH_LEN,
163 item->appInfo.peerData.shortAccountHash, D2D_SHORT_ACCOUNT_HASH_LEN) != EOK ||
164 memcpy_s(info->appInfo.peerData.shortUdidHash, D2D_SHORT_UDID_HASH_LEN,
165 item->appInfo.peerData.shortUdidHash, D2D_SHORT_UDID_HASH_LEN) != EOK ||
166 strcpy_s(info->appInfo.peerData.sessionName, sizeof(info->appInfo.peerData.sessionName),
167 item->appInfo.peerData.sessionName) != EOK ||
168 memcpy_s(&(item->appInfo.peerData), sizeof(item->appInfo.peerData), &(info->appInfo.peerData),
169 sizeof(info->appInfo.peerData)) != EOK) {
170 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
171 TRANS_LOGE(TRANS_SVC, "memcpy_s peerdata failed");
172 return SOFTBUS_MEM_ERR;
173 }
174 if (memcpy_s(info, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo)) != EOK) {
175 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
176 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
177 return SOFTBUS_MEM_ERR;
178 }
179 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
180 return SOFTBUS_OK;
181 }
182 }
183 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
184 return SOFTBUS_TRANS_NODE_NOT_FOUND;
185 }
186
TransPagingUpdatePidAndData(int32_t channelId,int32_t pid,char * data,uint32_t len)187 int32_t TransPagingUpdatePidAndData(int32_t channelId, int32_t pid, char *data, uint32_t len)
188 {
189 TRANS_CHECK_AND_RETURN_RET_LOGE((g_proxyChannelList != NULL && data != NULL && len <= EXTRA_DATA_MAX_LEN),
190 SOFTBUS_INVALID_PARAM, TRANS_CTRL, "g_proxyChannelList or item is null");
191 TRANS_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK,
192 SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
193 ProxyChannelInfo *item = NULL;
194 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
195 if (item->channelId == channelId) {
196 item->appInfo.myData.pid = pid;
197 item->appInfo.myData.dataLen = len;
198 if (len > 0 && memcpy_s(item->appInfo.myData.extraData, EXTRA_DATA_MAX_LEN, data, len) != EOK) {
199 TRANS_LOGE(TRANS_CTRL, "copy extraData failed");
200 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
201 return SOFTBUS_MEM_ERR;
202 }
203 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
204 return SOFTBUS_OK;
205 }
206 }
207 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
208 return SOFTBUS_TRANS_NODE_NOT_FOUND;
209 }
210
TransUpdateAuthSeqByChannelId(int32_t channelId,int32_t reqId)211 static int32_t TransUpdateAuthSeqByChannelId(int32_t channelId, int32_t reqId)
212 {
213 TRANS_CHECK_AND_RETURN_RET_LOGE(g_proxyChannelList != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL,
214 "g_proxyChannelList or item is null");
215 TRANS_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK,
216 SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
217 ProxyChannelInfo *item = NULL;
218 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
219 if (item->channelId == channelId) {
220 item->authReqId = (uint32_t)reqId;
221 item->retried = true;
222 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
223 return SOFTBUS_OK;
224 }
225 }
226 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
227 return SOFTBUS_TRANS_NODE_NOT_FOUND;
228 }
229
TransOnGenSuccess(uint32_t requestId,uint8_t * applyKey,uint32_t applyKeyLen)230 static void TransOnGenSuccess(uint32_t requestId, uint8_t *applyKey, uint32_t applyKeyLen)
231 {
232 TRANS_LOGI(TRANS_CTRL, "requestId=%{public}u", requestId);
233 if (applyKeyLen == 0 || applyKeyLen > D2D_APPLY_KEY_LEN || applyKey == NULL) {
234 TRANS_LOGE(TRANS_CTRL, "invalid applyKeyLen=%{public}u", applyKeyLen);
235 return;
236 }
237 int32_t channelId = 0;
238 int32_t ret = TransProxyGetProxyChannelIdByAuthReq(requestId, &channelId);
239 if (ret != SOFTBUS_OK) {
240 TRANS_LOGE(TRANS_CTRL, "get channel info by auth seq failed, req=%{public}u", requestId);
241 return;
242 }
243 uint8_t *authKey = (uint8_t *)SoftBusCalloc(applyKeyLen);
244 if (authKey == NULL) {
245 TRANS_LOGE(TRANS_CTRL, "SoftBusCalloc authKey failed");
246 return;
247 }
248 if (memcpy_s(authKey, applyKeyLen, applyKey, applyKeyLen) != EOK) {
249 TRANS_LOGE(TRANS_CTRL, "memcpy_s authKey failed");
250 SoftBusFree(authKey);
251 return;
252 }
253 TransProxyPagingHandshakeMsgToLoop(channelId, authKey, applyKeyLen);
254 }
255
TransOnGenFailed(uint32_t requestId,int32_t reason)256 static void TransOnGenFailed(uint32_t requestId, int32_t reason)
257 {
258 TRANS_LOGE(TRANS_CTRL, "requestId=%{public}u, reason=%{public}d", requestId, reason);
259 }
260
TransPagingBadKeyRetry(int32_t channelId)261 void TransPagingBadKeyRetry(int32_t channelId)
262 {
263 ProxyChannelInfo chan;
264 (void)memset_s(&chan, sizeof(ProxyChannelInfo), 0, sizeof(ProxyChannelInfo));
265 int32_t ret = TransProxyGetChanByChanId(channelId, &chan);
266 TRANS_CHECK_AND_RETURN_LOGE(ret == SOFTBUS_OK, TRANS_CTRL, "get channel info fail");
267 TRANS_CHECK_AND_RETURN_LOGE(!chan.retried, TRANS_CTRL, "bad key is Retried");
268 RequestBusinessInfo businessInfo;
269 (void)memset_s(&businessInfo, sizeof(RequestBusinessInfo), 0, sizeof(RequestBusinessInfo));
270 businessInfo.type = BUSINESS_TYPE_D2D;
271 if (strcpy_s(businessInfo.peerAccountHash, sizeof(businessInfo.peerAccountHash),
272 chan.appInfo.myData.calleeAccountId) != EOK) {
273 TRANS_LOGE(TRANS_CTRL, "cpy account id failed");
274 return;
275 }
276 if (ConvertBytesToHexString(businessInfo.udidHash, D2D_UDID_HASH_STR_LEN,
277 chan.appInfo.peerData.shortUdidHash, D2D_SHORT_UDID_HASH_LEN) != SOFTBUS_OK ||
278 ConvertBytesToHexString(businessInfo.accountHash, D2D_ACCOUNT_HASH_STR_LEN,
279 chan.appInfo.peerData.shortAccountHash, D2D_SHORT_ACCOUNT_HASH_LEN) != SOFTBUS_OK) {
280 TRANS_LOGE(TRANS_CTRL, "convert udidHash or account hex string failed");
281 return;
282 }
283 uint32_t authReqId = GenApplyKeySeq();
284 TRANS_LOGI(TRANS_CTRL, "bad key retry Gen apply key, authReqId=%{public}u", authReqId);
285 ret = TransUpdateAuthSeqByChannelId(channelId, authReqId);
286 TRANS_CHECK_AND_RETURN_LOGE(ret == SOFTBUS_OK, TRANS_CTRL, "update authreq fail, channelId=%{public}d", channelId);
287 GenApplyKeyCallback callback = {
288 .onGenSuccess = TransOnGenSuccess,
289 .onGenFailed = TransOnGenFailed,
290 };
291 ret = AuthGenApplyKey(&businessInfo, authReqId, chan.connId, &callback);
292 if (ret != SOFTBUS_OK) {
293 TRANS_LOGE(TRANS_CTRL, "AuthGenApplyKey fail, ret=%{public}d", ret);
294 }
295 }
296
TransProxyUpdateAckInfo(ProxyChannelInfo * info)297 static int32_t TransProxyUpdateAckInfo(ProxyChannelInfo *info)
298 {
299 TRANS_CHECK_AND_RETURN_RET_LOGE((g_proxyChannelList != NULL && info != NULL), SOFTBUS_INVALID_PARAM, TRANS_CTRL,
300 "g_proxyChannelList or item is null");
301 TRANS_CHECK_AND_RETURN_RET_LOGE(
302 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
303 ProxyChannelInfo *item = NULL;
304 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
305 if ((item->myId == info->myId) && (strncmp(item->identity, info->identity, sizeof(item->identity)) == 0)) {
306 item->peerId = info->peerId;
307 item->status = PROXY_CHANNEL_STATUS_COMPLETED;
308 item->timeout = 0;
309 item->appInfo.encrypt = info->appInfo.encrypt;
310 item->appInfo.algorithm = info->appInfo.algorithm;
311 item->appInfo.crc = info->appInfo.crc;
312 item->appInfo.myData.dataConfig = info->appInfo.myData.dataConfig;
313 item->appInfo.peerHandleId = info->appInfo.peerHandleId;
314 item->appInfo.channelCapability = info->appInfo.channelCapability;
315 if (memcpy_s(item->appInfo.sinkSessionKey, SESSION_KEY_LENGTH, info->appInfo.sinkSessionKey,
316 SESSION_KEY_LENGTH) != EOK) {
317 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
318 TRANS_LOGE(TRANS_SVC, "memcpy_s sink session key failed");
319 return SOFTBUS_MEM_ERR;
320 }
321 if (memcpy_s(&(item->appInfo.peerData), sizeof(item->appInfo.peerData),
322 &(info->appInfo.peerData), sizeof(info->appInfo.peerData)) != EOK ||
323 memcpy_s(info, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo)) != EOK) {
324 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
325 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
326 return SOFTBUS_MEM_ERR;
327 }
328 SoftbusHitraceStart(SOFTBUS_HITRACE_ID_VALID, (uint64_t)(item->channelId + ID_OFFSET));
329 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
330 return SOFTBUS_OK;
331 }
332 }
333 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
334 return SOFTBUS_TRANS_NODE_NOT_FOUND;
335 }
336
TransRefreshProxyTimesNative(int32_t channelId)337 int32_t TransRefreshProxyTimesNative(int32_t channelId)
338 {
339 TRANS_CHECK_AND_RETURN_RET_LOGE(
340 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
341 TRANS_CHECK_AND_RETURN_RET_LOGE(
342 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
343
344 ProxyChannelInfo *item = NULL;
345 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
346 if (item->myId == channelId) {
347 item->timeout = 0;
348 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
349 return SOFTBUS_OK;
350 }
351 }
352 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
353 return SOFTBUS_TRANS_NODE_NOT_FOUND;
354 }
355
TransProxyAddChanItem(ProxyChannelInfo * chan)356 static int32_t TransProxyAddChanItem(ProxyChannelInfo *chan)
357 {
358 TRANS_CHECK_AND_RETURN_RET_LOGE((g_proxyChannelList != NULL && chan != NULL), SOFTBUS_INVALID_PARAM, TRANS_CTRL,
359 "trans proxy add channel param nullptr!");
360 TRANS_CHECK_AND_RETURN_RET_LOGE(
361 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
362
363 ListAdd(&(g_proxyChannelList->list), &(chan->node));
364 g_proxyChannelList->cnt++;
365 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
366 return SOFTBUS_OK;
367 }
368
TransProxySpecialUpdateChanInfo(ProxyChannelInfo * channelInfo)369 int32_t TransProxySpecialUpdateChanInfo(ProxyChannelInfo *channelInfo)
370 {
371 TRANS_CHECK_AND_RETURN_RET_LOGE((g_proxyChannelList != NULL && channelInfo != NULL), SOFTBUS_INVALID_PARAM,
372 TRANS_CTRL, "g_proxyChannelList or channelInfo is NULL!");
373 TRANS_CHECK_AND_RETURN_RET_LOGE(
374 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
375
376 ProxyChannelInfo *item = NULL;
377 ProxyChannelInfo *nextNode = NULL;
378 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
379 if (item->channelId == channelInfo->channelId) {
380 if (channelInfo->reqId != -1) {
381 item->reqId = channelInfo->reqId;
382 }
383 if (channelInfo->isServer != -1) {
384 item->isServer = channelInfo->isServer;
385 }
386 if (channelInfo->type != CONNECT_TYPE_MAX) {
387 item->type = channelInfo->type;
388 }
389 if (channelInfo->status != -1) {
390 item->status = channelInfo->status;
391 }
392 if (channelInfo->status == PROXY_CHANNEL_STATUS_HANDSHAKEING) {
393 item->connId = channelInfo->connId;
394 }
395 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
396 return SOFTBUS_OK;
397 }
398 }
399 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
400 return SOFTBUS_TRANS_NODE_NOT_FOUND;
401 }
402
TransProxyGetChanByChanId(int32_t chanId,ProxyChannelInfo * chan)403 int32_t TransProxyGetChanByChanId(int32_t chanId, ProxyChannelInfo *chan)
404 {
405 TRANS_CHECK_AND_RETURN_RET_LOGE((g_proxyChannelList != NULL && chan != NULL), SOFTBUS_INVALID_PARAM, TRANS_CTRL,
406 "trans proxy get channel param nullptr!");
407 TRANS_CHECK_AND_RETURN_RET_LOGE(
408 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
409
410 ProxyChannelInfo *item = NULL;
411 ProxyChannelInfo *nextNode = NULL;
412
413 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
414 if (item->channelId == chanId) {
415 if (memcpy_s(chan, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo)) != EOK) {
416 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
417 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
418 return SOFTBUS_MEM_ERR;
419 }
420 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
421 return SOFTBUS_OK;
422 }
423 }
424 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
425 TRANS_LOGE(TRANS_CTRL, "proxy channel not found by chanId. chanId=%{public}d", chanId);
426 return SOFTBUS_TRANS_NODE_NOT_FOUND;
427 }
428
TransProxyGetChanByReqId(int32_t reqId,ProxyChannelInfo * chan)429 int32_t TransProxyGetChanByReqId(int32_t reqId, ProxyChannelInfo *chan)
430 {
431 ProxyChannelInfo *item = NULL;
432 TRANS_CHECK_AND_RETURN_RET_LOGE(
433 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
434 TRANS_CHECK_AND_RETURN_RET_LOGE(
435 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
436
437 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
438 if (item->reqId == reqId && item->status == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
439 *chan = *item;
440 break;
441 }
442 }
443 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
444 return SOFTBUS_OK;
445 }
446
TransProxyUpdateSinkAccessInfo(int32_t chanId,const AccessInfo * accessInfo)447 static int32_t TransProxyUpdateSinkAccessInfo(int32_t chanId, const AccessInfo *accessInfo)
448 {
449 TRANS_CHECK_AND_RETURN_RET_LOGE((g_proxyChannelList != NULL && accessInfo != NULL && accessInfo->localTokenId != 0),
450 SOFTBUS_INVALID_PARAM, TRANS_CTRL, "g_proxyChannelList is NULL or accessInfo is invalid!");
451 TRANS_CHECK_AND_RETURN_RET_LOGE(
452 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
453 uint32_t size = 0;
454 char accountId[ACCOUNT_UID_LEN_MAX] = { 0 };
455 int32_t ret = GetLocalAccountUidByUserId(accountId, ACCOUNT_UID_LEN_MAX, &size, accessInfo->userId);
456 if (ret != SOFTBUS_OK) {
457 TRANS_LOGE(TRANS_CTRL, "get current account failed. ret=%{public}d", ret);
458 }
459 ProxyChannelInfo *item = NULL;
460 ProxyChannelInfo *nextNode = NULL;
461 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
462 if (item->channelId == chanId && item->appInfo.myData.tokenType > ACCESS_TOKEN_TYPE_HAP) {
463 item->appInfo.myData.userId = accessInfo->userId;
464 item->appInfo.myData.tokenId = accessInfo->localTokenId;
465 if (memcpy_s(item->appInfo.myData.accountId, ACCOUNT_UID_LEN_MAX, accountId, size) != EOK) {
466 TRANS_LOGE(TRANS_CTRL, "memcpy current account failed.");
467 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
468 return SOFTBUS_MEM_ERR;
469 }
470 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
471 return SOFTBUS_OK;
472 }
473 }
474 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
475 return SOFTBUS_TRANS_NODE_NOT_FOUND;
476 }
477
TransProxyDelChanByReqId(int32_t reqId,int32_t errCode)478 void TransProxyDelChanByReqId(int32_t reqId, int32_t errCode)
479 {
480 ProxyChannelInfo *item = NULL;
481 ProxyChannelInfo *nextNode = NULL;
482
483 TRANS_CHECK_AND_RETURN_LOGE(
484 g_proxyChannelList != NULL, TRANS_CTRL, "g_proxyChannelList is null");
485 TRANS_CHECK_AND_RETURN_LOGE(
486 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, TRANS_CTRL, "lock mutex fail!");
487
488 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
489 if ((item->reqId == reqId) &&
490 (item->status == PROXY_CHANNEL_STATUS_PYH_CONNECTING)) {
491 ReleaseProxyChannelId(item->channelId);
492 ListDelete(&(item->node));
493 g_proxyChannelList->cnt--;
494 TRANS_LOGI(TRANS_CTRL, "del channelId by reqId. channelId=%{public}d", item->channelId);
495 SoftBusFree((void *)item->appInfo.fastTransData);
496 item->appInfo.fastTransData = NULL;
497 TransProxyPostOpenFailMsgToLoop(item, errCode);
498 }
499 }
500 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
501 return;
502 }
503
TransProxyDelChanByChanId(int32_t chanlId)504 void TransProxyDelChanByChanId(int32_t chanlId)
505 {
506 ProxyChannelInfo *item = NULL;
507 ProxyChannelInfo *nextNode = NULL;
508
509 TRANS_CHECK_AND_RETURN_LOGE(
510 g_proxyChannelList != NULL, TRANS_CTRL, "g_proxyChannelList is null");
511 TRANS_CHECK_AND_RETURN_LOGE(
512 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, TRANS_CTRL, "lock mutex fail!");
513
514 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
515 if (item->channelId == chanlId) {
516 ReleaseProxyChannelId(item->channelId);
517 ListDelete(&(item->node));
518 if (item->appInfo.fastTransData != NULL) {
519 SoftBusFree((void *)item->appInfo.fastTransData);
520 }
521 (void)memset_s(item->appInfo.sessionKey, sizeof(item->appInfo.sessionKey), 0,
522 sizeof(item->appInfo.sessionKey));
523 SoftBusFree(item);
524 g_proxyChannelList->cnt--;
525 break;
526 }
527 }
528 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
529 TRANS_LOGE(TRANS_CTRL, "del channelId by chanId! channelId=%{public}d", chanlId);
530 return;
531 }
532
TransProxyChanProcessByReqId(int32_t reqId,uint32_t connId,int32_t errCode)533 void TransProxyChanProcessByReqId(int32_t reqId, uint32_t connId, int32_t errCode)
534 {
535 ProxyChannelInfo *item = NULL;
536 TRANS_CHECK_AND_RETURN_LOGE(
537 g_proxyChannelList != NULL, TRANS_CTRL, "g_proxyChannelList is null");
538 TRANS_CHECK_AND_RETURN_LOGE(
539 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, TRANS_CTRL, "lock mutex fail!");
540
541 bool isUsing = false;
542 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
543 if (item->reqId == reqId && item->status == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
544 item->status = PROXY_CHANNEL_STATUS_HANDSHAKEING;
545 item->connId = connId;
546 isUsing = true;
547 TransAddConnRefByConnId(connId, (bool)item->isServer);
548 TransProxyPostHandshakeMsgToLoop(item->channelId);
549 }
550 }
551
552 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
553 if (!isUsing && errCode != SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND) {
554 TRANS_LOGW(TRANS_CTRL, "logical channel is already closed, connId=%{public}u", connId);
555 TransProxyCloseConnChannel(connId, false);
556 }
557 }
558
TransProxyReleaseChannelList(ListNode * proxyChannelList,int32_t errCode)559 static void TransProxyReleaseChannelList(ListNode *proxyChannelList, int32_t errCode)
560 {
561 TRANS_CHECK_AND_RETURN_LOGE(!IsListEmpty(proxyChannelList), TRANS_CTRL, "proxyChannelList is empty");
562
563 ProxyChannelInfo *removeNode = NULL;
564 ProxyChannelInfo *nextNode = NULL;
565 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, proxyChannelList, ProxyChannelInfo, node) {
566 ListDelete(&(removeNode->node));
567 if (removeNode->status == PROXY_CHANNEL_STATUS_HANDSHAKEING ||
568 removeNode->status == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
569 TransProxyOpenProxyChannelFail(removeNode->channelId, &(removeNode->appInfo), errCode);
570 } else {
571 OnProxyChannelClosed(removeNode->channelId, &(removeNode->appInfo));
572 }
573 if (removeNode->appInfo.fastTransData != NULL) {
574 SoftBusFree((void *)removeNode->appInfo.fastTransData);
575 }
576 SoftBusFree(removeNode);
577 }
578 }
579
TransProxyDelByConnId(uint32_t connId)580 void TransProxyDelByConnId(uint32_t connId)
581 {
582 ProxyChannelInfo *removeNode = NULL;
583 ProxyChannelInfo *nextNode = NULL;
584 ListNode proxyChannelList;
585
586 TRANS_CHECK_AND_RETURN_LOGE(g_proxyChannelList != NULL, TRANS_CTRL, "g_proxyChannelList is null");
587 TRANS_CHECK_AND_RETURN_LOGE(
588 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, TRANS_CTRL, "lock mutex fail!");
589
590 ListInit(&proxyChannelList);
591 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
592 if (removeNode->connId == connId) {
593 ReleaseProxyChannelId(removeNode->channelId);
594 ListDelete(&(removeNode->node));
595 g_proxyChannelList->cnt--;
596 ListAdd(&proxyChannelList, &removeNode->node);
597 TRANS_LOGI(TRANS_CTRL, "trans proxy del channel by connId=%{public}d", connId);
598 }
599 }
600 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
601 TransProxyReleaseChannelList(&proxyChannelList, SOFTBUS_TRANS_PROXY_DISCONNECTED);
602 }
603
TransProxyDelByChannelId(int32_t channelId,ProxyChannelInfo * channelInfo)604 static int32_t TransProxyDelByChannelId(int32_t channelId, ProxyChannelInfo *channelInfo)
605 {
606 ProxyChannelInfo *removeNode = NULL;
607 ProxyChannelInfo *nextNode = NULL;
608
609 TRANS_CHECK_AND_RETURN_RET_LOGE(
610 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
611 TRANS_CHECK_AND_RETURN_RET_LOGE(
612 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
613
614 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
615 if (removeNode->channelId == channelId) {
616 if (channelInfo != NULL) {
617 (void)memcpy_s(channelInfo, sizeof(ProxyChannelInfo), removeNode, sizeof(ProxyChannelInfo));
618 }
619 ReleaseProxyChannelId(removeNode->channelId);
620 if (removeNode->appInfo.fastTransData != NULL) {
621 SoftBusFree((void *)removeNode->appInfo.fastTransData);
622 }
623 ListDelete(&(removeNode->node));
624 SoftBusFree(removeNode);
625 g_proxyChannelList->cnt--;
626 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
627 TRANS_LOGI(TRANS_CTRL, "trans proxy del channel by channelId=%{public}d", channelId);
628 return SOFTBUS_OK;
629 }
630 }
631 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
632 return SOFTBUS_TRANS_NODE_NOT_FOUND;
633 }
634
TransPagingResetChan(ProxyChannelInfo * chanInfo)635 int32_t TransPagingResetChan(ProxyChannelInfo *chanInfo)
636 {
637 TRANS_CHECK_AND_RETURN_RET_LOGE(chanInfo != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL, "chanInfo is null");
638 TRANS_CHECK_AND_RETURN_RET_LOGE(g_proxyChannelList != NULL,
639 SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
640 TRANS_CHECK_AND_RETURN_RET_LOGE(
641 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
642 ProxyChannelInfo *removeNode = NULL;
643 ProxyChannelInfo *nextNode = NULL;
644 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
645 if (removeNode->myId == chanInfo->myId && removeNode->peerId == chanInfo->peerId) {
646 if (memcpy_s(chanInfo, sizeof(ProxyChannelInfo), removeNode, sizeof(ProxyChannelInfo)) != EOK) {
647 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
648 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
649 return SOFTBUS_MEM_ERR;
650 }
651 ReleaseProxyChannelId(removeNode->channelId);
652 if (removeNode->appInfo.fastTransData != NULL) {
653 SoftBusFree((void *)removeNode->appInfo.fastTransData);
654 }
655 ListDelete(&(removeNode->node));
656 SoftBusFree(removeNode);
657 g_proxyChannelList->cnt--;
658 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
659 TRANS_LOGI(TRANS_CTRL, "trans proxy reset channelId=%{public}d", chanInfo->channelId);
660 return SOFTBUS_OK;
661 }
662 }
663 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
664
665 return SOFTBUS_TRANS_NODE_NOT_FOUND;
666 }
667
TransProxyResetChan(ProxyChannelInfo * chanInfo)668 static int32_t TransProxyResetChan(ProxyChannelInfo *chanInfo)
669 {
670 ProxyChannelInfo *removeNode = NULL;
671 ProxyChannelInfo *nextNode = NULL;
672
673 TRANS_CHECK_AND_RETURN_RET_LOGE(
674 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
675 TRANS_CHECK_AND_RETURN_RET_LOGE(
676 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
677
678 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
679 if (ResetChanIsEqual(removeNode->status, removeNode, chanInfo)) {
680 if (memcpy_s(chanInfo, sizeof(ProxyChannelInfo), removeNode, sizeof(ProxyChannelInfo)) != EOK) {
681 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
682 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
683 return SOFTBUS_MEM_ERR;
684 }
685 ReleaseProxyChannelId(removeNode->channelId);
686 if (removeNode->appInfo.fastTransData != NULL) {
687 SoftBusFree((void *)removeNode->appInfo.fastTransData);
688 }
689 ListDelete(&(removeNode->node));
690 SoftBusFree(removeNode);
691 g_proxyChannelList->cnt--;
692 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
693 TRANS_LOGI(TRANS_CTRL, "trans proxy reset channelId=%{public}d", chanInfo->channelId);
694 return SOFTBUS_OK;
695 }
696 }
697 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
698
699 return SOFTBUS_TRANS_NODE_NOT_FOUND;
700 }
701
TransProxyGetRecvMsgChanInfo(int16_t myId,int16_t peerId,ProxyChannelInfo * chanInfo)702 static int32_t TransProxyGetRecvMsgChanInfo(int16_t myId, int16_t peerId, ProxyChannelInfo *chanInfo)
703 {
704 ProxyChannelInfo *item = NULL;
705
706 TRANS_CHECK_AND_RETURN_RET_LOGE(
707 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
708 TRANS_CHECK_AND_RETURN_RET_LOGE(
709 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
710
711 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
712 if ((item->myId == myId) && (item->peerId == peerId)) {
713 if (item->status == PROXY_CHANNEL_STATUS_COMPLETED) {
714 item->timeout = 0;
715 }
716 if (memcpy_s(chanInfo, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo)) != EOK) {
717 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
718 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
719 return SOFTBUS_MEM_ERR;
720 }
721 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
722 return SOFTBUS_OK;
723 }
724 }
725 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
726 return SOFTBUS_TRANS_NODE_NOT_FOUND;
727 }
728
TransProxyKeepAliveChan(ProxyChannelInfo * chanInfo)729 static int32_t TransProxyKeepAliveChan(ProxyChannelInfo *chanInfo)
730 {
731 ProxyChannelInfo *item = NULL;
732
733 TRANS_CHECK_AND_RETURN_RET_LOGE(
734 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
735 TRANS_CHECK_AND_RETURN_RET_LOGE(
736 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
737
738 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
739 if (ChanIsEqual(item, chanInfo)) {
740 if (item->status == PROXY_CHANNEL_STATUS_KEEPLIVEING || item->status == PROXY_CHANNEL_STATUS_COMPLETED) {
741 item->timeout = 0;
742 item->status = PROXY_CHANNEL_STATUS_COMPLETED;
743 }
744 if (memcpy_s(chanInfo, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo)) != EOK) {
745 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
746 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
747 return SOFTBUS_MEM_ERR;
748 }
749 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
750 return SOFTBUS_OK;
751 }
752 }
753 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
754 return SOFTBUS_TRANS_NODE_NOT_FOUND;
755 }
756
TransProxyGetSendMsgChanInfo(int32_t channelId,ProxyChannelInfo * chanInfo)757 int32_t TransProxyGetSendMsgChanInfo(int32_t channelId, ProxyChannelInfo *chanInfo)
758 {
759 ProxyChannelInfo *item = NULL;
760
761 TRANS_CHECK_AND_RETURN_RET_LOGE(
762 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
763 TRANS_CHECK_AND_RETURN_RET_LOGE(
764 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
765
766 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
767 if (item->channelId == channelId) {
768 if (item->status == PROXY_CHANNEL_STATUS_COMPLETED) {
769 item->timeout = 0;
770 }
771 if (memcpy_s(chanInfo, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo)) != EOK) {
772 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
773 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
774 return SOFTBUS_MEM_ERR;
775 }
776 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
777 return SOFTBUS_OK;
778 }
779 }
780 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
781 return SOFTBUS_TRANS_NODE_NOT_FOUND;
782 }
783
TransProxyGetNewChanSeq(int32_t channelId)784 int32_t TransProxyGetNewChanSeq(int32_t channelId)
785 {
786 ProxyChannelInfo *item = NULL;
787 int32_t seq = 0;
788
789 TRANS_CHECK_AND_RETURN_RET_LOGE(
790 g_proxyChannelList != NULL, seq, TRANS_CTRL, "g_proxyChannelList is null");
791 TRANS_CHECK_AND_RETURN_RET_LOGE(
792 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, seq, TRANS_CTRL, "lock mutex fail!");
793
794 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
795 if (item->channelId == channelId) {
796 seq = item->seq;
797 item->seq++;
798 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
799 return seq;
800 }
801 }
802 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
803 return seq;
804 }
805
TransProxyGetAuthId(int32_t channelId,AuthHandle * authHandle)806 int32_t TransProxyGetAuthId(int32_t channelId, AuthHandle *authHandle)
807 {
808 TRANS_CHECK_AND_RETURN_RET_LOGE(
809 authHandle != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL, "authHandle is null");
810 ProxyChannelInfo *item = NULL;
811 TRANS_CHECK_AND_RETURN_RET_LOGE(
812 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
813 TRANS_CHECK_AND_RETURN_RET_LOGE(
814 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
815 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
816 if (item->channelId == channelId) {
817 *authHandle = item->authHandle;
818 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
819 return SOFTBUS_OK;
820 }
821 }
822 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
823 return SOFTBUS_TRANS_NODE_NOT_FOUND;
824 }
825
TransProxyGetChannelCapaByChanId(int32_t channelId,uint32_t * channelCapability)826 int32_t TransProxyGetChannelCapaByChanId(int32_t channelId, uint32_t *channelCapability)
827 {
828 TRANS_CHECK_AND_RETURN_RET_LOGE(
829 channelCapability != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL, "channelCapability is null");
830 ProxyChannelInfo *item = NULL;
831 TRANS_CHECK_AND_RETURN_RET_LOGE(
832 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
833 TRANS_CHECK_AND_RETURN_RET_LOGE(
834 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
835 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
836 if (item->channelId == channelId) {
837 if (item->status == PROXY_CHANNEL_STATUS_COMPLETED) {
838 item->timeout = 0;
839 }
840 *channelCapability = item->appInfo.channelCapability;
841 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
842 return SOFTBUS_OK;
843 }
844 }
845 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
846 TRANS_LOGE(TRANS_CTRL, "not found ChannelCapability by channelId=%{public}d", channelId);
847 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
848 }
849
TransProxyGetSessionKeyByChanId(int32_t channelId,char * sessionKey,uint32_t sessionKeySize)850 int32_t TransProxyGetSessionKeyByChanId(int32_t channelId, char *sessionKey, uint32_t sessionKeySize)
851 {
852 TRANS_CHECK_AND_RETURN_RET_LOGE(
853 sessionKey != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL, "sessionKey is null");
854 ProxyChannelInfo *item = NULL;
855 TRANS_CHECK_AND_RETURN_RET_LOGE(
856 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
857 TRANS_CHECK_AND_RETURN_RET_LOGE(
858 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
859 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
860 if (item->channelId == channelId) {
861 if (item->status == PROXY_CHANNEL_STATUS_COMPLETED) {
862 item->timeout = 0;
863 }
864 if (memcpy_s(sessionKey, sessionKeySize, item->appInfo.sessionKey,
865 sizeof(item->appInfo.sessionKey)) != EOK) {
866 TRANS_LOGE(TRANS_CTRL, "memcpy_s fail!");
867 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
868 return SOFTBUS_MEM_ERR;
869 }
870 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
871 return SOFTBUS_OK;
872 }
873 }
874 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
875 TRANS_LOGE(TRANS_CTRL, "not found ChannelInfo by channelId=%{public}d", channelId);
876 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
877 }
878
TransProxyProcessErrMsg(ProxyChannelInfo * info,int32_t errCode)879 void TransProxyProcessErrMsg(ProxyChannelInfo *info, int32_t errCode)
880 {
881 TRANS_LOGW(TRANS_CTRL, "TransProxyProcessErrMsg errCode=%{public}d", errCode);
882 TRANS_CHECK_AND_RETURN_LOGE(
883 TransProxyGetChanByChanId(info->myId, info) == SOFTBUS_OK, TRANS_CTRL, "TransProxyGetChanByChanId fail");
884 if ((info->appInfo.appType == APP_TYPE_NORMAL) || (info->appInfo.appType == APP_TYPE_AUTH)) {
885 TransProxyCloseProxyChannel(info->channelId);
886 (void)TransProxyOpenProxyChannelFail(info->channelId, &(info->appInfo), errCode);
887 }
888 }
889
TransProxyGetAppInfoById(int16_t channelId,AppInfo * appInfo)890 int32_t TransProxyGetAppInfoById(int16_t channelId, AppInfo *appInfo)
891 {
892 ProxyChannelInfo *item = NULL;
893
894 TRANS_CHECK_AND_RETURN_RET_LOGE(
895 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
896 TRANS_CHECK_AND_RETURN_RET_LOGE(
897 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
898
899 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
900 if (item->myId == channelId) {
901 if (memcpy_s(appInfo, sizeof(AppInfo), &(item->appInfo), sizeof(item->appInfo)) != EOK) {
902 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
903 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
904 return SOFTBUS_MEM_ERR;
905 }
906 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
907 return SOFTBUS_OK;
908 }
909 }
910 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
911 return SOFTBUS_TRANS_NODE_NOT_FOUND;
912 }
913
TransProxyGetReqIdAndStatus(int32_t myId,int32_t * reqId,int8_t * status)914 static int32_t TransProxyGetReqIdAndStatus(int32_t myId, int32_t *reqId, int8_t *status)
915 {
916 TRANS_CHECK_AND_RETURN_RET_LOGE(
917 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "proxy channel list not init");
918
919 int32_t ret = SoftBusMutexLock(&g_proxyChannelList->lock);
920 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
921 ProxyChannelInfo *item = NULL;
922 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
923 if (item->myId == myId) {
924 *reqId = item->reqId;
925 *status = item->status;
926 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
927 return SOFTBUS_OK;
928 }
929 }
930 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
931 TRANS_LOGE(TRANS_CTRL, "not found proxyChannelInfo by channelId=%{public}d", myId);
932 return SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND;
933 }
934
935 static const ConfigTypeMap g_configTypeMap[] = {
936 { CHANNEL_TYPE_AUTH, BUSINESS_TYPE_BYTE, SOFTBUS_INT_AUTH_MAX_BYTES_LENGTH },
937 { CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, SOFTBUS_INT_AUTH_MAX_MESSAGE_LENGTH },
938 { CHANNEL_TYPE_PROXY, BUSINESS_TYPE_BYTE, SOFTBUS_INT_MAX_BYTES_NEW_LENGTH },
939 { CHANNEL_TYPE_PROXY, BUSINESS_TYPE_MESSAGE, SOFTBUS_INT_MAX_MESSAGE_NEW_LENGTH },
940 };
941
FindConfigType(int32_t channelType,int32_t businessType)942 static int32_t FindConfigType(int32_t channelType, int32_t businessType)
943 {
944 uint32_t size = (uint32_t)sizeof(g_configTypeMap) / sizeof(ConfigTypeMap);
945 for (uint32_t i = 0; i < size; i++) {
946 if ((g_configTypeMap[i].channelType == channelType) && (g_configTypeMap[i].businessType == businessType)) {
947 return g_configTypeMap[i].configType;
948 }
949 }
950 return SOFTBUS_CONFIG_TYPE_MAX;
951 }
952
TransGetLocalConfig(int32_t channelType,int32_t businessType,uint32_t * len)953 static int32_t TransGetLocalConfig(int32_t channelType, int32_t businessType, uint32_t *len)
954 {
955 ConfigType configType = (ConfigType)FindConfigType(channelType, businessType);
956 if (configType == SOFTBUS_CONFIG_TYPE_MAX) {
957 TRANS_LOGE(TRANS_CTRL, "Invalid channelType=%{public}d, businessType=%{public}d", channelType, businessType);
958 return SOFTBUS_INVALID_PARAM;
959 }
960 uint32_t maxLen;
961 if (SoftbusGetConfig(configType, (unsigned char *)&maxLen, sizeof(maxLen)) != SOFTBUS_OK) {
962 TRANS_LOGE(TRANS_CTRL, "get fail configType=%{public}d", configType);
963 return SOFTBUS_GET_CONFIG_VAL_ERR;
964 }
965 *len = maxLen;
966 TRANS_LOGI(TRANS_CTRL, "get local config len=%{public}u", *len);
967 return SOFTBUS_OK;
968 }
969
TransProxyProcessDataConfig(AppInfo * appInfo)970 static int32_t TransProxyProcessDataConfig(AppInfo *appInfo)
971 {
972 if (appInfo == NULL) {
973 TRANS_LOGE(TRANS_CTRL, "appInfo is null");
974 return SOFTBUS_INVALID_PARAM;
975 }
976 if (appInfo->businessType != BUSINESS_TYPE_MESSAGE && appInfo->businessType != BUSINESS_TYPE_BYTE) {
977 TRANS_LOGE(TRANS_CTRL, "invalid businessType=%{public}d", appInfo->businessType);
978 return SOFTBUS_OK;
979 }
980 if (appInfo->peerData.dataConfig != 0) {
981 appInfo->myData.dataConfig = MIN(appInfo->myData.dataConfig, appInfo->peerData.dataConfig);
982 TRANS_LOGI(TRANS_CTRL, "process dataConfig succ. dataConfig=%{public}u", appInfo->myData.dataConfig);
983 return SOFTBUS_OK;
984 }
985 ConfigType configType = appInfo->businessType == BUSINESS_TYPE_BYTE ? SOFTBUS_INT_PROXY_MAX_BYTES_LENGTH :
986 SOFTBUS_INT_PROXY_MAX_MESSAGE_LENGTH;
987 if (SoftbusGetConfig(configType, (unsigned char *)&appInfo->myData.dataConfig,
988 sizeof(appInfo->myData.dataConfig)) != SOFTBUS_OK) {
989 TRANS_LOGE(TRANS_CTRL, "get config failed, configType=%{public}d", configType);
990 return SOFTBUS_GET_CONFIG_VAL_ERR;
991 }
992 TRANS_LOGI(TRANS_CTRL, "process dataConfig=%{public}d", appInfo->myData.dataConfig);
993 return SOFTBUS_OK;
994 }
995
TransProxyReportAuditEvent(ProxyChannelInfo * info,SoftbusAuditType auditType,int32_t errCode)996 static void TransProxyReportAuditEvent(ProxyChannelInfo *info, SoftbusAuditType auditType, int32_t errCode)
997 {
998 TransAuditExtra extra = {
999 .hostPkg = NULL,
1000 .result = TRANS_AUDIT_DISCONTINUE,
1001 .errcode = errCode,
1002 .auditType = auditType,
1003 .localIp = NULL,
1004 .localPort = NULL,
1005 .localDevId = NULL,
1006 .localSessName = NULL,
1007 .peerIp = NULL,
1008 .peerPort = NULL,
1009 .peerDevId = NULL,
1010 .peerSessName = NULL
1011 };
1012 if (info != NULL) {
1013 extra.localChannelId = info->myId;
1014 extra.peerChannelId = info->peerId;
1015 }
1016 TRANS_AUDIT(AUDIT_SCENE_OPEN_SESSION, extra);
1017 }
1018
TransPagingHandshakeUnPackErrMsg(ProxyChannelInfo * chan,const ProxyMessage * msg,int32_t * errCode)1019 int32_t TransPagingHandshakeUnPackErrMsg(ProxyChannelInfo *chan, const ProxyMessage *msg, int32_t *errCode)
1020 {
1021 if (errCode == NULL || chan == NULL || msg == NULL) {
1022 TRANS_LOGE(TRANS_CTRL, "invalid param errCode.");
1023 return SOFTBUS_INVALID_PARAM;
1024 }
1025 cJSON *root = cJSON_ParseWithLength(msg->data, msg->dataLen);
1026 if (root == NULL) {
1027 TRANS_LOGE(TRANS_CTRL, "parse json failed.");
1028 return SOFTBUS_CREATE_JSON_ERR;
1029 }
1030 if (!GetJsonObjectInt32Item(root, ERR_CODE, errCode)) {
1031 cJSON_Delete(root);
1032 return SOFTBUS_PARSE_JSON_ERR;
1033 }
1034 if (!GetJsonObjectNumberItem(root, JSON_KEY_PAGING_SINK_CHANNEL_ID, (int32_t *)&chan->peerId)) {
1035 cJSON_Delete(root);
1036 return SOFTBUS_PARSE_JSON_ERR;
1037 }
1038 chan->appInfo.peerData.channelId = chan->peerId;
1039 TRANS_LOGE(TRANS_CTRL, "remote device is faulty, errCode=%{public}d", *errCode);
1040
1041 cJSON_Delete(root);
1042 return SOFTBUS_OK;
1043 }
1044
TransProxyHandshakeUnpackErrMsg(ProxyChannelInfo * info,const ProxyMessage * msg,int32_t * errCode)1045 static int32_t TransProxyHandshakeUnpackErrMsg(ProxyChannelInfo *info, const ProxyMessage *msg, int32_t *errCode)
1046 {
1047 if (errCode == NULL) {
1048 TRANS_LOGE(TRANS_CTRL, "errCode is invalid.");
1049 return SOFTBUS_INVALID_PARAM;
1050 }
1051 int32_t ret = TransProxyUnPackHandshakeErrMsg(msg->data, errCode, msg->dataLen);
1052 if (ret == SOFTBUS_OK) {
1053 TransEventExtra extra = {
1054 .result = EVENT_STAGE_RESULT_FAILED,
1055 .errcode = *errCode,
1056 .socketName = NULL,
1057 .channelId = info->myId,
1058 .peerChannelId = info->peerId,
1059 .peerNetworkId = NULL,
1060 .callerPkg = NULL,
1061 .calleePkg = NULL
1062 };
1063 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_HANDSHAKE_REPLY, extra);
1064 TransProxyReportAuditEvent(info, AUDIT_EVENT_MSG_ERROR, *errCode);
1065 return SOFTBUS_OK;
1066 }
1067 return ret;
1068 }
1069
TransProxyHandshakeUnpackRightMsg(ProxyChannelInfo * info,const ProxyMessage * msg,int32_t errCode,uint16_t * fastDataSize)1070 static int32_t TransProxyHandshakeUnpackRightMsg(
1071 ProxyChannelInfo *info, const ProxyMessage *msg, int32_t errCode, uint16_t *fastDataSize)
1072 {
1073 if (fastDataSize == NULL) {
1074 TRANS_LOGE(TRANS_CTRL, "fastDataSize is invalid.");
1075 return SOFTBUS_INVALID_PARAM;
1076 }
1077 int32_t ret = TransProxyUnpackHandshakeAckMsg(msg->data, info, msg->dataLen, fastDataSize);
1078 if (ret != SOFTBUS_OK) {
1079 TransProxyReportAuditEvent(info, AUDIT_EVENT_PACKETS_ERROR, errCode);
1080 TRANS_LOGE(TRANS_CTRL, "UnpackHandshakeAckMsg failed");
1081 return ret;
1082 }
1083 TRANS_LOGI(TRANS_CTRL,
1084 "recv Handshake ack myChannelid=%{public}d, peerChannelId=%{public}d, identity=%{public}s, crc=%{public}d",
1085 info->myId, info->peerId, info->identity, info->appInfo.crc);
1086 return SOFTBUS_OK;
1087 }
1088
TransProxyProcessHandshakeAckMsg(const ProxyMessage * msg)1089 void TransProxyProcessHandshakeAckMsg(const ProxyMessage *msg)
1090 {
1091 SoftBusHitraceChainBegin("TransProxyProcessHandshakeAckMsg");
1092 uint16_t fastDataSize = 0;
1093 ProxyChannelInfo info = {
1094 .myId = msg->msgHead.myId,
1095 .peerId = msg->msgHead.peerId
1096 };
1097
1098 if (TransProxyGetAppInfoById(info.myId, &(info.appInfo)) != SOFTBUS_OK) {
1099 TRANS_LOGE(TRANS_CTRL, "failed to get peer data info");
1100 SoftBusHitraceChainEnd();
1101 return;
1102 }
1103 int32_t errCode = SOFTBUS_OK;
1104 if (TransProxyHandshakeUnpackErrMsg(&info, msg, &errCode) == SOFTBUS_OK) {
1105 TransProxyProcessErrMsg(&info, errCode);
1106 goto EXIT;
1107 }
1108 if (TransProxyHandshakeUnpackRightMsg(&info, msg, errCode, &fastDataSize) != SOFTBUS_OK) {
1109 goto EXIT;
1110 }
1111
1112 if (TransProxyProcessDataConfig(&(info.appInfo)) != SOFTBUS_OK) {
1113 TRANS_LOGE(TRANS_CTRL, "ProcessDataConfig failed");
1114 goto EXIT;
1115 }
1116
1117 if (TransProxyUpdateAckInfo(&info) != SOFTBUS_OK) {
1118 TRANS_LOGE(TRANS_CTRL, "UpdateAckInfo failed");
1119 goto EXIT;
1120 }
1121
1122 info.appInfo.peerData.channelId = msg->msgHead.peerId;
1123 if (info.appInfo.fastTransDataSize <= 0 || (fastDataSize > 0 && fastDataSize == info.appInfo.fastTransDataSize)) {
1124 (void)OnProxyChannelOpened(info.channelId, &(info.appInfo), PROXY_CHANNEL_CLIENT);
1125 } else {
1126 uint32_t outLen;
1127 char *buf = TransProxyPackFastData(&(info.appInfo), &outLen);
1128 if (buf == NULL) {
1129 TRANS_LOGE(TRANS_CTRL, "failed to pack bytes.");
1130 goto EXIT;
1131 }
1132 (void)TransSendMsg(info.channelId, CHANNEL_TYPE_PROXY, buf, outLen, info.appInfo.businessType);
1133 SoftBusFree(buf);
1134 (void)OnProxyChannelOpened(info.channelId, &(info.appInfo), PROXY_CHANNEL_CLIENT);
1135 }
1136 EXIT:
1137 (void)memset_s(info.appInfo.sessionKey, sizeof(info.appInfo.sessionKey), 0, sizeof(info.appInfo.sessionKey));
1138 SoftBusHitraceChainEnd();
1139 return;
1140 }
1141
TransProxyGetLocalInfo(ProxyChannelInfo * chan)1142 static int32_t TransProxyGetLocalInfo(ProxyChannelInfo *chan)
1143 {
1144 bool noNeedGetPkg = (chan->appInfo.appType == APP_TYPE_INNER);
1145 if (!noNeedGetPkg) {
1146 if (TransProxyGetPkgName(chan->appInfo.myData.sessionName,
1147 chan->appInfo.myData.pkgName, sizeof(chan->appInfo.myData.pkgName)) != SOFTBUS_OK) {
1148 TRANS_LOGE(TRANS_CTRL, "channelId=%{public}d proc handshake get pkg name fail", chan->channelId);
1149 return SOFTBUS_TRANS_PEER_SESSION_NOT_CREATED;
1150 }
1151
1152 if (TransProxyGetUidAndPidBySessionName(chan->appInfo.myData.sessionName,
1153 &chan->appInfo.myData.uid, &chan->appInfo.myData.pid) != SOFTBUS_OK) {
1154 TRANS_LOGE(TRANS_CTRL, "channelId=%{public}d proc handshake get uid pid fail", chan->channelId);
1155 return SOFTBUS_TRANS_PEER_SESSION_NOT_CREATED;
1156 }
1157 }
1158
1159 InfoKey key = STRING_KEY_UUID;
1160 if (chan->appInfo.appType == APP_TYPE_AUTH) {
1161 key = STRING_KEY_DEV_UDID;
1162 }
1163 int32_t ret = LnnGetLocalStrInfo(key, chan->appInfo.myData.deviceId, sizeof(chan->appInfo.myData.deviceId));
1164 TRANS_CHECK_AND_RETURN_RET_LOGE(
1165 ret == SOFTBUS_OK, ret, TRANS_CTRL, "channelId=%{public}d Handshake get local info fail", chan->channelId);
1166 chan->appInfo.myData.tokenType = ACEESS_TOKEN_TYPE_INVALID;
1167 if (chan->appInfo.appType != APP_TYPE_INNER) {
1168 ret = GetTokenTypeBySessionName(chan->appInfo.myData.sessionName, &chan->appInfo.myData.tokenType);
1169 TRANS_CHECK_AND_RETURN_RET_LOGE(
1170 ret == SOFTBUS_OK, ret, TRANS_CTRL, "get tokenType info fail, ret=%{public}d", ret);
1171 }
1172 FillHapSinkAclInfoToAppInfo(&chan->appInfo);
1173 return SOFTBUS_OK;
1174 }
1175
CheckAppTypeAndMsgHead(const ProxyMessageHead * msgHead,const AppInfo * appInfo)1176 static inline int32_t CheckAppTypeAndMsgHead(const ProxyMessageHead *msgHead, const AppInfo *appInfo)
1177 {
1178 if (((msgHead->cipher & ENCRYPTED) == 0) && (appInfo->appType != APP_TYPE_AUTH)) {
1179 return SOFTBUS_TRANS_PROXY_ERROR_APP_TYPE;
1180 }
1181 return SOFTBUS_OK;
1182 }
1183
SelectRouteType(ConnectType type,RouteType * routeType)1184 static void SelectRouteType(ConnectType type, RouteType *routeType)
1185 {
1186 if (type == CONNECT_TCP) {
1187 *routeType = WIFI_STA;
1188 } else if (type == CONNECT_BR) {
1189 *routeType = BT_BR;
1190 } else if (type == CONNECT_BLE) {
1191 *routeType = BT_BLE;
1192 } else if (type == CONNECT_SLE) {
1193 *routeType = BT_SLE;
1194 } else if (type == CONNECT_BLE_DIRECT) {
1195 *routeType = BT_BLE;
1196 }
1197 }
1198
ConstructProxyChannelInfo(ProxyChannelInfo * chan,const ProxyMessage * msg,int16_t newChanId,const ConnectionInfo * info)1199 static void ConstructProxyChannelInfo(
1200 ProxyChannelInfo *chan, const ProxyMessage *msg, int16_t newChanId, const ConnectionInfo *info)
1201 {
1202 // always be client when communicating with WinPC
1203 chan->isServer = (msg->msgHead.cipher & CS_MODE) == 0 ? 0 : 1;
1204 if (chan->isServer == 0) {
1205 chan->deviceTypeIsWinpc = true;
1206 }
1207 chan->status = PROXY_CHANNEL_STATUS_COMPLETED;
1208 chan->connId = msg->connId;
1209 chan->myId = newChanId;
1210 chan->channelId = newChanId;
1211 chan->peerId = msg->msgHead.peerId;
1212 chan->authHandle = msg->authHandle;
1213 chan->type = info->type;
1214 if (chan->type == CONNECT_BLE || chan->type == CONNECT_BLE_DIRECT) {
1215 chan->bleProtocolType = info->bleInfo.protocol;
1216 } else if (chan->type == CONNECT_SLE || chan->type == CONNECT_SLE_DIRECT) {
1217 chan->sleProtocolType = info->sleInfo.protocol;
1218 }
1219
1220 SelectRouteType(info->type, &chan->appInfo.routeType);
1221 }
1222
TransProxyFillDataConfig(AppInfo * appInfo)1223 static int32_t TransProxyFillDataConfig(AppInfo *appInfo)
1224 {
1225 if (appInfo == NULL) {
1226 TRANS_LOGE(TRANS_CTRL, "appInfo is null");
1227 return SOFTBUS_INVALID_PARAM;
1228 }
1229 if (appInfo->appType == APP_TYPE_AUTH) {
1230 appInfo->businessType = BUSINESS_TYPE_BYTE;
1231 }
1232 if (appInfo->businessType != BUSINESS_TYPE_MESSAGE && appInfo->businessType != BUSINESS_TYPE_BYTE) {
1233 TRANS_LOGI(TRANS_CTRL, "invalid businessType=%{public}d", appInfo->businessType);
1234 return SOFTBUS_OK;
1235 }
1236 if (appInfo->peerData.dataConfig != 0) {
1237 uint32_t localDataConfig = 0;
1238 if (TransGetLocalConfig(CHANNEL_TYPE_PROXY, appInfo->businessType, &localDataConfig) != SOFTBUS_OK) {
1239 TRANS_LOGE(TRANS_CTRL, "get local config failed, businessType=%{public}d", appInfo->businessType);
1240 return SOFTBUS_GET_CONFIG_VAL_ERR;
1241 }
1242 appInfo->myData.dataConfig = MIN(localDataConfig, appInfo->peerData.dataConfig);
1243 TRANS_LOGI(TRANS_CTRL, "fill dataConfig success. dataConfig=%{public}u", appInfo->myData.dataConfig);
1244 return SOFTBUS_OK;
1245 }
1246 ConfigType configType = appInfo->businessType == BUSINESS_TYPE_BYTE ? SOFTBUS_INT_PROXY_MAX_BYTES_LENGTH :
1247 SOFTBUS_INT_PROXY_MAX_MESSAGE_LENGTH;
1248 if (SoftbusGetConfig(configType, (unsigned char *)&appInfo->myData.dataConfig,
1249 sizeof(appInfo->myData.dataConfig)) != SOFTBUS_OK) {
1250 TRANS_LOGE(TRANS_CTRL, "get config failed, configType=%{public}d", configType);
1251 return SOFTBUS_GET_CONFIG_VAL_ERR;
1252 }
1253 TRANS_LOGD(TRANS_CTRL, "fill dataConfig=%{public}d", appInfo->myData.dataConfig);
1254 return SOFTBUS_OK;
1255 }
1256
CheckAndGenerateSinkSessionKey(ProxyChannelInfo * chan)1257 static int32_t CheckAndGenerateSinkSessionKey(ProxyChannelInfo *chan)
1258 {
1259 (void)LnnGetNetworkIdByUuid(chan->appInfo.peerData.deviceId, chan->appInfo.peerNetWorkId, NETWORK_ID_BUF_LEN);
1260 int32_t osType = 0;
1261 GetOsTypeByNetworkId(chan->appInfo.peerNetWorkId, &osType);
1262 if (osType != OH_OS_TYPE) {
1263 DisableCapabilityBit(&chan->appInfo.channelCapability, TRANS_CHANNEL_SINK_GENERATE_KEY_OFFSET);
1264 }
1265 if (GetCapabilityBit(chan->appInfo.channelCapability, TRANS_CHANNEL_SINK_GENERATE_KEY_OFFSET)) {
1266 EnableCapabilityBit(&chan->appInfo.channelCapability, TRANS_CHANNEL_SINK_KEY_ENCRYPT_OFFSET);
1267 return SoftBusGenerateSessionKey(chan->appInfo.sinkSessionKey, SESSION_KEY_LENGTH);
1268 }
1269 return SOFTBUS_OK;
1270 }
1271
TransProxyFillChannelInfo(const ProxyMessage * msg,ProxyChannelInfo * chan)1272 static int32_t TransProxyFillChannelInfo(const ProxyMessage *msg, ProxyChannelInfo *chan)
1273 {
1274 int32_t ret = TransProxyUnpackHandshakeMsg(msg->data, chan, msg->dataLen);
1275 if (ret != SOFTBUS_OK) {
1276 TransProxyReportAuditEvent(chan, AUDIT_EVENT_PACKETS_ERROR, ret);
1277 TRANS_LOGE(TRANS_CTRL, "UnpackHandshakeMsg fail.");
1278 return ret;
1279 }
1280 ret = CheckAndGenerateSinkSessionKey(chan);
1281 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "Generate sink SessionKey failed.");
1282 ConnectionInfo info;
1283 (void)memset_s(&info, sizeof(ConnectionInfo), 0, sizeof(ConnectionInfo));
1284 ret = ConnGetConnectionInfo(msg->connId, &info);
1285 if (ret != SOFTBUS_OK) {
1286 TRANS_LOGE(TRANS_CTRL, "GetConnectionInfo fail. connId=%{public}u", msg->connId);
1287 return ret;
1288 }
1289 ConnectType type;
1290 if (ConnGetTypeByConnectionId(msg->connId, &type) != SOFTBUS_OK) {
1291 return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
1292 }
1293 SelectRouteType(type, &chan->appInfo.routeType);
1294
1295 int16_t newChanId = (int16_t)(GenerateChannelId(false));
1296 ConstructProxyChannelInfo(chan, msg, newChanId, &info);
1297
1298 ret = TransProxyGetLocalInfo(chan);
1299 if (ret != SOFTBUS_OK) {
1300 return ret;
1301 }
1302
1303 if ((chan->appInfo.appType == APP_TYPE_AUTH) &&
1304 (!CheckSessionNameValidOnAuthChannel(chan->appInfo.myData.sessionName))) {
1305 TRANS_LOGE(TRANS_CTRL, "proxy auth check sessionname valid.");
1306 return SOFTBUS_TRANS_AUTH_NOTALLOW_OPENED;
1307 }
1308
1309 if (CheckAppTypeAndMsgHead(&msg->msgHead, &chan->appInfo) != SOFTBUS_OK) {
1310 TRANS_LOGE(TRANS_CTRL, "only auth channel surpport plain text data");
1311 return SOFTBUS_TRANS_PROXY_ERROR_APP_TYPE;
1312 }
1313
1314 if (chan->appInfo.appType == APP_TYPE_NORMAL && chan->appInfo.callingTokenId != TOKENID_NOT_SET) {
1315 (void)LnnGetNetworkIdByUuid(chan->appInfo.peerData.deviceId, chan->appInfo.peerNetWorkId, NETWORK_ID_BUF_LEN);
1316 int32_t osType = 0;
1317 GetOsTypeByNetworkId(chan->appInfo.peerNetWorkId, &osType);
1318 if (osType != OH_OS_TYPE) {
1319 TRANS_LOGI(TRANS_CTRL, "not support acl check osType=%{public}d", osType);
1320 } else if (GetCapabilityBit(chan->appInfo.channelCapability, TRANS_CHANNEL_ACL_CHECK_OFFSET)) {
1321 ret = TransCheckServerAccessControl(&chan->appInfo);
1322 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "acl check failed.");
1323 } else {
1324 TRANS_LOGI(TRANS_CTRL, "not support acl check");
1325 }
1326 }
1327
1328 if (CheckSecLevelPublic(chan->appInfo.myData.sessionName, chan->appInfo.peerData.sessionName) != SOFTBUS_OK) {
1329 return SOFTBUS_PERMISSION_SERVER_DENIED;
1330 }
1331
1332 ret = TransProxyFillDataConfig(&chan->appInfo);
1333 if (ret != SOFTBUS_OK) {
1334 TRANS_LOGE(TRANS_CTRL, "fill dataConfig fail.");
1335 return ret;
1336 }
1337 return SOFTBUS_OK;
1338 }
1339
TransProxyProcessHandshakeAuthMsg(const ProxyMessage * msg)1340 void TransProxyProcessHandshakeAuthMsg(const ProxyMessage *msg)
1341 {
1342 AppInfo appInfo;
1343 int32_t ret = TransProxyGetAppInfoByChanId(msg->msgHead.myId, &appInfo);
1344 (void)memset_s(appInfo.sessionKey, sizeof(appInfo.sessionKey), 0, sizeof(appInfo.sessionKey));
1345 if (ret != SOFTBUS_OK) {
1346 return;
1347 }
1348 if (((uint32_t)appInfo.transFlag & TRANS_FLAG_HAS_CHANNEL_AUTH) == 0) {
1349 return;
1350 }
1351 int64_t authSeq = appInfo.authSeq;
1352 AuthSessionProcessAuthData(authSeq, (uint8_t *)msg->data, msg->dataLen);
1353 }
1354
TransProxyFastDataRecv(ProxyChannelInfo * chan)1355 static void TransProxyFastDataRecv(ProxyChannelInfo *chan)
1356 {
1357 TRANS_LOGD(TRANS_CTRL, "begin, fastTransDataSize=%{public}d", chan->appInfo.fastTransDataSize);
1358 TransReceiveData receiveData;
1359 receiveData.data = (void *)chan->appInfo.fastTransData;
1360 if (chan->appInfo.businessType == BUSINESS_TYPE_MESSAGE && chan->appInfo.routeType == WIFI_STA) {
1361 receiveData.dataLen = chan->appInfo.fastTransDataSize + FAST_EXT_MSG_SIZE;
1362 } else {
1363 receiveData.dataLen = chan->appInfo.fastTransDataSize + FAST_EXT_BYTE_SIZE;
1364 }
1365 if (chan->appInfo.businessType == BUSINESS_TYPE_MESSAGE) {
1366 receiveData.dataType = TRANS_SESSION_MESSAGE;
1367 } else {
1368 receiveData.dataType = TRANS_SESSION_BYTES;
1369 }
1370 if (NotifyClientMsgReceived(chan->appInfo.myData.pkgName, chan->appInfo.myData.pid,
1371 chan->channelId, &receiveData) != SOFTBUS_OK) {
1372 TRANS_LOGE(TRANS_CTRL, "TransProxyFastDataRecv err");
1373 chan->appInfo.fastTransDataSize = 0;
1374 }
1375 TRANS_LOGD(TRANS_CTRL, "ok");
1376 return;
1377 }
1378
ReleaseChannelInfo(ProxyChannelInfo * chan)1379 static void ReleaseChannelInfo(ProxyChannelInfo *chan)
1380 {
1381 if (chan == NULL) {
1382 return;
1383 }
1384 if (chan->appInfo.fastTransData != NULL) {
1385 SoftBusFree((void*)chan->appInfo.fastTransData);
1386 }
1387 SoftBusFree(chan);
1388 }
1389
FillProxyHandshakeExtra(TransEventExtra * extra,ProxyChannelInfo * chan,char * socketName,NodeInfo * nodeInfo)1390 static void FillProxyHandshakeExtra(
1391 TransEventExtra *extra, ProxyChannelInfo *chan, char *socketName, NodeInfo *nodeInfo)
1392 {
1393 if (strcpy_s(socketName, SESSION_NAME_SIZE_MAX, chan->appInfo.myData.sessionName) != EOK) {
1394 TRANS_LOGW(TRANS_CTRL, "strcpy_s socketName failed");
1395 }
1396 extra->calleePkg = NULL;
1397 extra->callerPkg = NULL;
1398 extra->channelId = chan->myId;
1399 extra->peerChannelId = chan->peerId;
1400 extra->socketName = socketName;
1401 extra->authId = chan->authHandle.authId;
1402 extra->connectionId = (int32_t)chan->connId;
1403 extra->channelType = chan->appInfo.appType == APP_TYPE_AUTH ? CHANNEL_TYPE_AUTH : CHANNEL_TYPE_PROXY;
1404 extra->linkType = chan->type;
1405
1406 if (chan->appInfo.appType == APP_TYPE_AUTH &&
1407 strcpy_s(nodeInfo->deviceInfo.deviceUdid, UDID_BUF_LEN, chan->appInfo.peerData.deviceId) != EOK) {
1408 extra->peerUdid = nodeInfo->deviceInfo.deviceUdid;
1409 } else if (chan->appInfo.appType != APP_TYPE_AUTH &&
1410 LnnGetRemoteNodeInfoById(chan->appInfo.peerData.deviceId, CATEGORY_UUID, nodeInfo) == SOFTBUS_OK) {
1411 extra->peerUdid = nodeInfo->deviceInfo.deviceUdid;
1412 extra->peerDevVer = nodeInfo->deviceInfo.deviceVersion;
1413 }
1414 if (LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, nodeInfo->masterUdid, UDID_BUF_LEN) == SOFTBUS_OK) {
1415 extra->localUdid = nodeInfo->masterUdid;
1416 }
1417 }
1418
TransProxySendHandShakeMsgWhenInner(uint32_t connId,ProxyChannelInfo * chan,int32_t retCode)1419 static int32_t TransProxySendHandShakeMsgWhenInner(uint32_t connId, ProxyChannelInfo *chan, int32_t retCode)
1420 {
1421 if (chan->appInfo.appType != APP_TYPE_INNER) {
1422 return SOFTBUS_OK;
1423 }
1424 if (chan->appInfo.fastTransData != NULL && chan->appInfo.fastTransDataSize > 0) {
1425 TransProxyFastDataRecv(chan);
1426 }
1427 chan->appInfo.myHandleId = 0;
1428 int32_t ret = TransProxyAckHandshake(connId, chan, SOFTBUS_OK);
1429 if (ret != SOFTBUS_OK) {
1430 TRANS_LOGE(
1431 TRANS_CTRL, "AckHandshake fail channelId=%{public}d, connId=%{public}u", chan->channelId, connId);
1432 (void)OnProxyChannelClosed(chan->channelId, &(chan->appInfo));
1433 TransProxyDelChanByChanId(chan->channelId);
1434 return ret;
1435 }
1436 return SOFTBUS_OK;
1437 }
1438
TransServerProxyChannelOpened(ProxyChannelInfo * chan,TransEventExtra * extra,int32_t proxyChannelId)1439 static int32_t TransServerProxyChannelOpened(ProxyChannelInfo *chan, TransEventExtra *extra, int32_t proxyChannelId)
1440 {
1441 extra->result = EVENT_STAGE_RESULT_OK;
1442 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL_SERVER, EVENT_STAGE_HANDSHAKE_START, *extra);
1443 int32_t ret = OnProxyChannelOpened(proxyChannelId, &(chan->appInfo), PROXY_CHANNEL_SERVER);
1444 if (ret != SOFTBUS_OK) {
1445 TRANS_LOGE(TRANS_CTRL, "Trans send on channel opened request fail. ret=%{public}d.", ret);
1446 (void)TransProxyAckHandshake(chan->connId, chan, ret);
1447 TransProxyDelChanByChanId(proxyChannelId);
1448 return ret;
1449 }
1450 ret = TransProxySendHandShakeMsgWhenInner(chan->connId, chan, SOFTBUS_OK);
1451 if (ret != SOFTBUS_OK) {
1452 return ret;
1453 }
1454 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL_SERVER, EVENT_STAGE_HANDSHAKE_REPLY, *extra);
1455 return SOFTBUS_OK;
1456 }
1457
TransProxyProcessHandshakeMsg(const ProxyMessage * msg)1458 void TransProxyProcessHandshakeMsg(const ProxyMessage *msg)
1459 {
1460 SoftBusHitraceChainBegin("TransProxyProcessHandshakeMsg");
1461 if (msg == NULL) {
1462 TRANS_LOGE(TRANS_CTRL, "invalid param");
1463 SoftBusHitraceChainEnd();
1464 return;
1465 }
1466 TRANS_LOGI(TRANS_CTRL, "recv Handshake myChannelId=%{public}d, peerChannelId=%{public}d", msg->msgHead.myId,
1467 msg->msgHead.peerId);
1468 ProxyChannelInfo *chan = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1469 if (chan == NULL) {
1470 TRANS_LOGW(TRANS_CTRL, "proxy handshake calloc failed.");
1471 SoftBusHitraceChainEnd();
1472 return;
1473 }
1474 int32_t ret = TransProxyFillChannelInfo(msg, chan);
1475 if ((ret == SOFTBUS_TRANS_PEER_SESSION_NOT_CREATED || ret == SOFTBUS_TRANS_CHECK_ACL_FAILED ||
1476 ret == SOFTBUS_PERMISSION_SERVER_DENIED) && (TransProxyAckHandshake(msg->connId, chan, ret) != SOFTBUS_OK)) {
1477 TRANS_LOGE(TRANS_CTRL, "ErrHandshake fail, connId=%{public}u.", msg->connId);
1478 }
1479 char tmpSocketName[SESSION_NAME_SIZE_MAX] = { 0 };
1480 NodeInfo nodeInfo;
1481 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1482 TransEventExtra extra = { 0 };
1483 FillProxyHandshakeExtra(&extra, chan, tmpSocketName, &nodeInfo);
1484 chan->connId = msg->connId;
1485 int32_t proxyChannelId = chan->channelId;
1486 if (ret != SOFTBUS_OK) {
1487 ReleaseProxyChannelId(proxyChannelId);
1488 ReleaseChannelInfo(chan);
1489 goto EXIT_ERR;
1490 }
1491 TransCreateConnByConnId(chan->connId, (bool)chan->isServer);
1492 if ((ret = TransProxyAddChanItem(chan)) != SOFTBUS_OK) {
1493 TRANS_LOGE(TRANS_CTRL, "AddChanItem fail");
1494 ReleaseProxyChannelId(proxyChannelId);
1495 ReleaseChannelInfo(chan);
1496 goto EXIT_ERR;
1497 }
1498 if (chan->appInfo.appType == APP_TYPE_NORMAL) {
1499 ret = CheckCollabRelation(&(chan->appInfo), chan->channelId, CHANNEL_TYPE_PROXY);
1500 if (ret == SOFTBUS_OK) {
1501 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL_SERVER, EVENT_STAGE_HANDSHAKE_REPLY, extra);
1502 SoftBusHitraceChainEnd();
1503 return;
1504 } else if (ret != SOFTBUS_TRANS_NOT_NEED_CHECK_RELATION) {
1505 (void)TransProxyAckHandshake(chan->connId, chan, ret);
1506 TransProxyDelChanByChanId(proxyChannelId);
1507 goto EXIT_ERR;
1508 }
1509 }
1510 ret = TransServerProxyChannelOpened(chan, &extra, proxyChannelId);
1511 if (ret != SOFTBUS_OK) {
1512 goto EXIT_ERR;
1513 }
1514 SoftBusHitraceChainEnd();
1515 return;
1516 EXIT_ERR:
1517 extra.result = EVENT_STAGE_RESULT_FAILED;
1518 extra.errcode = ret;
1519 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL_SERVER, EVENT_STAGE_HANDSHAKE_REPLY, extra);
1520 SoftBusHitraceChainEnd();
1521 }
1522
TransProxyUpdateReplyCnt(int32_t channelId)1523 static int32_t TransProxyUpdateReplyCnt(int32_t channelId)
1524 {
1525 TRANS_CHECK_AND_RETURN_RET_LOGE(
1526 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
1527 TRANS_CHECK_AND_RETURN_RET_LOGE(
1528 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
1529 ProxyChannelInfo *item = NULL;
1530 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
1531 if (item->channelId == channelId) {
1532 item->appInfo.waitOpenReplyCnt = CHANNEL_OPEN_SUCCESS;
1533 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1534 return SOFTBUS_OK;
1535 }
1536 }
1537 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1538 TRANS_LOGE(TRANS_CTRL, "proxy channel not found by channelId. channelId=%{public}d", channelId);
1539 return SOFTBUS_TRANS_NODE_NOT_FOUND;
1540 }
1541
HandleProxyChanelOpened(ProxyChannelInfo * chan,int32_t channelId)1542 static int32_t HandleProxyChanelOpened(ProxyChannelInfo *chan, int32_t channelId)
1543 {
1544 int32_t ret = TransProxyAckHandshake(chan->connId, chan, SOFTBUS_OK);
1545 if (ret != SOFTBUS_OK) {
1546 TRANS_LOGE(
1547 TRANS_CTRL, "AckHandshake fail channelId=%{public}d, connId=%{public}u", channelId, chan->connId);
1548 (void)OnProxyChannelClosed(channelId, &(chan->appInfo));
1549 TransProxyDelChanByChanId(channelId);
1550 return ret;
1551 }
1552 ret = OnProxyChannelBind(channelId, &(chan->appInfo));
1553 if (ret != SOFTBUS_OK) {
1554 TRANS_LOGE(TRANS_CTRL, "OnProxyChannelBind fail channelId=%{public}d, connId=%{public}u", channelId,
1555 chan->connId);
1556 TransProxyDelChanByChanId(channelId);
1557 return ret;
1558 }
1559 return SOFTBUS_OK;
1560 }
1561
HandleProxyGenUkResult(uint32_t requestId,int32_t ukId,int32_t reason)1562 static void HandleProxyGenUkResult(uint32_t requestId, int32_t ukId, int32_t reason)
1563 {
1564 UkRequestNode ukRequestNode;
1565 (void)memset_s(&ukRequestNode, sizeof(UkRequestNode), 0, sizeof(UkRequestNode));
1566 int32_t ret = TransUkRequestGetRequestInfoByRequestId(requestId, &ukRequestNode);
1567 if (ret != SOFTBUS_OK) {
1568 TRANS_LOGE(TRANS_CTRL, "get uk acl info failed, ret=%{public}d", ret);
1569 (void)TransUkRequestDeleteItem(requestId);
1570 return;
1571 }
1572 ProxyChannelInfo chan;
1573 (void)memset_s(&chan, sizeof(ProxyChannelInfo), 0, sizeof(ProxyChannelInfo));
1574 ret = TransProxyGetChanByChanId(ukRequestNode.channelId, &chan);
1575 if (ret != SOFTBUS_OK) {
1576 TRANS_LOGE(TRANS_CTRL, "get proxy channelInfo failed, channelId=%{public}d, ret=%{public}d",
1577 ukRequestNode.channelId, ret);
1578 (void)TransUkRequestDeleteItem(requestId);
1579 return;
1580 }
1581 if (reason != SOFTBUS_OK) {
1582 TRANS_LOGE(
1583 TRANS_CTRL, "gen uk failed, channelId=%{public}d, reason=%{public}d", ukRequestNode.channelId, reason);
1584 (void)TransProxyAckHandshake(chan.connId, &chan, reason);
1585 (void)OnProxyChannelClosed(ukRequestNode.channelId, &(chan.appInfo));
1586 TransProxyDelChanByChanId(ukRequestNode.channelId);
1587 (void)memset_s(
1588 chan.appInfo.sinkSessionKey, sizeof(chan.appInfo.sinkSessionKey), 0, sizeof(chan.appInfo.sinkSessionKey));
1589 (void)memset_s(
1590 chan.appInfo.sessionKey, sizeof(chan.appInfo.sessionKey), 0, sizeof(chan.appInfo.sessionKey));
1591 (void)TransUkRequestDeleteItem(requestId);
1592 return;
1593 }
1594 chan.appInfo.myData.userKeyId = ukId;
1595 (void)HandleProxyChanelOpened(&chan, ukRequestNode.channelId);
1596 (void)memset_s(
1597 chan.appInfo.sinkSessionKey, sizeof(chan.appInfo.sinkSessionKey), 0, sizeof(chan.appInfo.sinkSessionKey));
1598 (void)memset_s(
1599 chan.appInfo.sessionKey, sizeof(chan.appInfo.sessionKey), 0, sizeof(chan.appInfo.sessionKey));
1600 (void)TransUkRequestDeleteItem(requestId);
1601 }
1602
OnProxyGenUkSuccess(uint32_t requestId,int32_t ukId)1603 static void OnProxyGenUkSuccess(uint32_t requestId, int32_t ukId)
1604 {
1605 HandleProxyGenUkResult(requestId, ukId, SOFTBUS_OK);
1606 }
1607
OnProxyGenUkFailed(uint32_t requestId,int32_t reason)1608 static void OnProxyGenUkFailed(uint32_t requestId, int32_t reason)
1609 {
1610 HandleProxyGenUkResult(requestId, 0, reason);
1611 }
1612
1613 static AuthGenUkCallback proxyAuthGenUkCallback = {
1614 .onGenSuccess = OnProxyGenUkSuccess,
1615 .onGenFailed = OnProxyGenUkFailed,
1616 };
1617
TransHandleProxyChanelOpened(int32_t channelId,ProxyChannelInfo * chan,const AccessInfo * accessInfo)1618 static int32_t TransHandleProxyChanelOpened(
1619 int32_t channelId, ProxyChannelInfo *chan, const AccessInfo *accessInfo)
1620 {
1621 if (GetCapabilityBit(chan->appInfo.channelCapability, TRANS_CHANNEL_SINK_GENERATE_KEY_OFFSET)) {
1622 if (accessInfo != NULL && accessInfo->userId == INVALID_USER_ID &&
1623 chan->appInfo.myData.tokenType > ACCESS_TOKEN_TYPE_HAP) {
1624 (void)DisableCapabilityBit(&chan->appInfo.channelCapability, TRANS_CHANNEL_SINK_KEY_ENCRYPT_OFFSET);
1625 return HandleProxyChanelOpened(chan, channelId);
1626 }
1627 int32_t ret = GetUserkeyIdByAClInfo(
1628 &chan->appInfo, channelId, CHANNEL_TYPE_PROXY, &chan->appInfo.myData.userKeyId, &proxyAuthGenUkCallback);
1629 if (ret == SOFTBUS_TRANS_GEN_USER_KEY) {
1630 return SOFTBUS_OK;
1631 }
1632 if (ret == SOFTBUS_AUTH_ACL_NOT_FOUND && SoftBusSaCanUseDeviceKey(chan->appInfo.myData.tokenId)) {
1633 (void)DisableCapabilityBit(&chan->appInfo.channelCapability, TRANS_CHANNEL_SINK_KEY_ENCRYPT_OFFSET);
1634 return HandleProxyChanelOpened(chan, channelId);
1635 }
1636 if (ret != SOFTBUS_OK) {
1637 (void)TransProxyAckHandshake(chan->connId, chan, ret);
1638 (void)OnProxyChannelClosed(channelId, &(chan->appInfo));
1639 TransProxyDelChanByChanId(channelId);
1640 return SOFTBUS_OK;
1641 }
1642 }
1643 return HandleProxyChanelOpened(chan, channelId);
1644 }
1645
TransDealProxyChannelOpenResult(int32_t channelId,int32_t openResult,const AccessInfo * accessInfo,pid_t callingPid)1646 int32_t TransDealProxyChannelOpenResult(
1647 int32_t channelId, int32_t openResult, const AccessInfo *accessInfo, pid_t callingPid)
1648 {
1649 ProxyChannelInfo chan = { 0 };
1650 int32_t ret = TransProxyGetChanByChanId(channelId, &chan);
1651 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL,
1652 "get proxy channelInfo failed, channelId=%{public}d, ret=%{public}d", channelId, ret);
1653
1654 if (callingPid != 0 && chan.appInfo.myData.pid != callingPid) {
1655 TRANS_LOGE(TRANS_CTRL,
1656 "pid does not match callingPid, pid=%{public}d, callingPid=%{public}d, channelId=%{public}d",
1657 chan.appInfo.myData.pid, callingPid, channelId);
1658 return SOFTBUS_TRANS_CHECK_PID_ERROR;
1659 }
1660 if (chan.isD2D) {
1661 ret = TransProxyUpdateReplyCnt(channelId);
1662 if (ret != SOFTBUS_OK) {
1663 TRANS_LOGE(TRANS_CTRL, "TransProxyUpdateReplyCnt fail channelId=%{public}d", chan.channelId);
1664 (void)OnProxyChannelClosed(chan.channelId, &(chan.appInfo));
1665 TransProxyDelChanByChanId(chan.channelId);
1666 return ret;
1667 }
1668 ret = TransPagingAckHandshake(&chan, openResult);
1669 if (ret != SOFTBUS_OK) {
1670 TRANS_LOGE(TRANS_CTRL,
1671 "AckHandshake fail channelId=%{public}d, connId=%{public}u", chan.channelId, chan.connId);
1672 (void)OnProxyChannelClosed(chan.channelId, &(chan.appInfo));
1673 TransProxyDelChanByChanId(chan.channelId);
1674 return ret;
1675 }
1676 return OnProxyChannelBind(chan.channelId, &chan.appInfo);
1677 }
1678 (void)TransProxyUpdateSinkAccessInfo(channelId, accessInfo);
1679 ret = TransProxyGetChanByChanId(channelId, &chan);
1680 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL,
1681 "get proxy channelInfo failed, channelId=%{public}d, ret=%{public}d", channelId, ret);
1682 ret = TransProxyUpdateReplyCnt(channelId);
1683 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL,
1684 "update waitOpenReplyCnt failed, channelId=%{public}d, ret=%{public}d", channelId, ret);
1685 if (openResult != SOFTBUS_OK) {
1686 TRANS_LOGE(TRANS_CTRL, "open proxy channel failed, ret=%{public}d", openResult);
1687 (void)TransProxyAckHandshake(chan.connId, &chan, openResult);
1688 TransProxyDelChanByChanId(channelId);
1689 return SOFTBUS_OK;
1690 }
1691
1692 if (chan.appInfo.fastTransData != NULL && chan.appInfo.fastTransDataSize > 0) {
1693 TransProxyFastDataRecv(&chan);
1694 }
1695 chan.appInfo.myHandleId = 0;
1696 return TransHandleProxyChanelOpened(channelId, &chan, accessInfo);
1697 }
1698
TransCheckProxyChannelOpenStatus(int32_t channelId,int32_t * curCount)1699 static int32_t TransCheckProxyChannelOpenStatus(int32_t channelId, int32_t *curCount)
1700 {
1701 TRANS_CHECK_AND_RETURN_RET_LOGE(
1702 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
1703 TRANS_CHECK_AND_RETURN_RET_LOGE(
1704 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
1705
1706 ProxyChannelInfo *item = NULL;
1707 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
1708 if (item->channelId == channelId) {
1709 if (item->appInfo.waitOpenReplyCnt != CHANNEL_OPEN_SUCCESS) {
1710 item->appInfo.waitOpenReplyCnt++;
1711 }
1712 *curCount = item->appInfo.waitOpenReplyCnt;
1713 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1714 return SOFTBUS_OK;
1715 }
1716 }
1717 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1718 TRANS_LOGE(TRANS_CTRL, "proxy channel not found by channelId. channelId=%{public}d", channelId);
1719 return SOFTBUS_TRANS_NODE_NOT_FOUND;
1720 }
1721
TransAsyncProxyChannelTask(int32_t channelId)1722 void TransAsyncProxyChannelTask(int32_t channelId)
1723 {
1724 int32_t curCount = 0;
1725 int32_t ret = TransCheckProxyChannelOpenStatus(channelId, &curCount);
1726 if (ret != SOFTBUS_OK) {
1727 TRANS_LOGE(TRANS_CTRL,
1728 "check proxy channel open statue failed, channelId=%{public}d, ret=%{public}d", channelId, ret);
1729 return;
1730 }
1731 if (curCount == CHANNEL_OPEN_SUCCESS) {
1732 TRANS_LOGI(TRANS_CTRL, "Open proxy channel success, channelId=%{public}d", channelId);
1733 return;
1734 }
1735 ProxyChannelInfo chan;
1736 (void)memset_s(&chan, sizeof(ProxyChannelInfo), 0, sizeof(ProxyChannelInfo));
1737 ret = TransProxyGetChanByChanId(channelId, &chan);
1738 if (ret != SOFTBUS_OK) {
1739 TRANS_LOGE(TRANS_CTRL, "get proxy channel info by channelId=%{public}d failed, ret=%{public}d", channelId, ret);
1740 return;
1741 }
1742 if (curCount >= LOOPER_REPLY_CNT_MAX) {
1743 TRANS_LOGE(TRANS_CTRL, "Open proxy channel timeout, channelId=%{public}d", channelId);
1744 if (chan.isD2D) {
1745 (void)TransPagingAckHandshake(&chan, SOFTBUS_TRANS_OPEN_CHANNEL_NEGTIATE_TIMEOUT);
1746 } else {
1747 (void)TransProxyAckHandshake(chan.connId, &chan, SOFTBUS_TRANS_OPEN_CHANNEL_NEGTIATE_TIMEOUT);
1748 }
1749 (void)OnProxyChannelClosed(channelId, &(chan.appInfo));
1750 TransProxyDelChanByChanId(channelId);
1751 return;
1752 }
1753 TRANS_LOGI(TRANS_CTRL, "Open proxy channelId=%{public}d not finished, generate new task and waiting", channelId);
1754 uint32_t delayTime = (curCount <= LOOPER_SEPARATE_CNT) ? FAST_INTERVAL_MILLISECOND : SLOW_INTERVAL_MILLISECOND;
1755 TransCheckChannelOpenToLooperDelay(channelId, CHANNEL_TYPE_PROXY, delayTime);
1756 }
1757
TransGetRemoteDeviceIdByReqId(int32_t requestId,char * peerNetworkId)1758 static int32_t TransGetRemoteDeviceIdByReqId(int32_t requestId, char *peerNetworkId)
1759 {
1760 TRANS_CHECK_AND_RETURN_RET_LOGE(
1761 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "proxy channel list not init");
1762
1763 int32_t ret = SoftBusMutexLock(&g_proxyChannelList->lock);
1764 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
1765
1766 ProxyChannelInfo *item = NULL;
1767 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
1768 if (item->reqId == requestId) {
1769 if (memcpy_s(peerNetworkId, DEVICE_ID_SIZE_MAX, item->appInfo.peerNetWorkId, DEVICE_ID_SIZE_MAX) != EOK) {
1770 TRANS_LOGE(TRANS_CTRL, "memcpy_s peerNetworkId failed");
1771 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1772 return SOFTBUS_MEM_ERR;
1773 }
1774 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1775 return SOFTBUS_OK;
1776 }
1777 }
1778 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1779 TRANS_LOGE(TRANS_CTRL, "proxy channel not found by requestId=%{public}d", requestId);
1780 return SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND;
1781 }
1782
TransProxyProcessReNegotiateMsg(const ProxyMessage * msg,const ProxyChannelInfo * info)1783 static int32_t TransProxyProcessReNegotiateMsg(const ProxyMessage *msg, const ProxyChannelInfo *info)
1784 {
1785 TRANS_LOGW(TRANS_CTRL, "receive reNegotiate msg, retry one time");
1786 AuthConnInfo authConnInfo;
1787 (void)memset_s(&authConnInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
1788 int32_t ret = GetAuthConnInfoByConnId(msg->connId, &authConnInfo);
1789 if (ret != SOFTBUS_OK) {
1790 TRANS_LOGE(TRANS_CTRL, "get authConnInfo by connId=%{public}u fail, ret=%{public}d", msg->connId, ret);
1791 return ret;
1792 }
1793
1794 ret = TransReNegotiateSessionKey(&authConnInfo, info->myId);
1795 if (ret != SOFTBUS_OK) {
1796 TransProxyNegoSessionKeyFail(info->myId, ret);
1797 TRANS_LOGE(TRANS_CTRL, "generate session key failed ret=%{public}d", ret);
1798 return ret;
1799 }
1800 TRANS_LOGI(TRANS_CTRL, "call regenerate sessionKey succ");
1801 return SOFTBUS_OK;
1802 }
1803
TransProxyProcessResetMsgHelper(const ProxyChannelInfo * info,const ProxyMessage * msg)1804 static void TransProxyProcessResetMsgHelper(const ProxyChannelInfo *info, const ProxyMessage *msg)
1805 {
1806 if (info->status == PROXY_CHANNEL_STATUS_HANDSHAKEING) {
1807 int32_t errCode = ((msg->msgHead.cipher & BAD_CIPHER) == BAD_CIPHER) ?
1808 SOFTBUS_TRANS_BAD_KEY : SOFTBUS_TRANS_HANDSHAKE_ERROR;
1809 TransProxyUnPackRestErrMsg(msg->data, &errCode, msg->dataLen);
1810 TRANS_LOGE(TRANS_CTRL, "TransProxyProcessResetMsg errCode=%{public}d", errCode);
1811 TransProxyOpenProxyChannelFail(info->channelId, &(info->appInfo), errCode);
1812 } else if (info->status == PROXY_CHANNEL_STATUS_COMPLETED) {
1813 TransEventExtra extra = {
1814 .result = EVENT_STAGE_RESULT_OK,
1815 .socketName = NULL,
1816 .channelId = msg->msgHead.myId,
1817 .peerChannelId = msg->msgHead.peerId,
1818 .peerNetworkId = NULL,
1819 .callerPkg = NULL,
1820 .calleePkg = NULL
1821 };
1822 TRANS_EVENT(EVENT_SCENE_CLOSE_CHANNEL_PASSIVE, EVENT_STAGE_CLOSE_CHANNEL, extra);
1823 OnProxyChannelClosed(info->channelId, &(info->appInfo));
1824 }
1825 (void)TransProxyCloseConnChannelReset(msg->connId, (info->isServer == 0), info->isServer, info->deviceTypeIsWinpc);
1826 if ((msg->msgHead.cipher & BAD_CIPHER) == BAD_CIPHER) {
1827 TRANS_LOGE(TRANS_CTRL, "clear bad key cipher=%{public}d, authId=%{public}" PRId64 ", keyIndex=%{public}d",
1828 msg->msgHead.cipher, msg->authHandle.authId, msg->keyIndex);
1829 RemoveAuthSessionKeyByIndex(msg->authHandle.authId, msg->keyIndex, (AuthLinkType)msg->authHandle.type);
1830 }
1831 }
1832
TransProxyProcessResetMsg(const ProxyMessage * msg)1833 void TransProxyProcessResetMsg(const ProxyMessage *msg)
1834 {
1835 SoftBusHitraceChainBegin("TransProxyProcessResetMsg");
1836 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1837 if (info == NULL) {
1838 TRANS_LOGE(TRANS_CTRL, "ProxyProcessResetMsg calloc failed.");
1839 SoftBusHitraceChainEnd();
1840 return;
1841 }
1842
1843 TRANS_LOGI(TRANS_CTRL, "recv reset myChannelId=%{public}d, peerChanelId=%{public}d, cipher=%{public}d",
1844 msg->msgHead.myId, msg->msgHead.peerId, msg->msgHead.cipher);
1845 if (TransProxyUnpackIdentity(msg->data, info->identity, sizeof(info->identity), msg->dataLen) != SOFTBUS_OK) {
1846 TRANS_LOGE(TRANS_CTRL, "reset identity fail");
1847 SoftBusFree(info);
1848 SoftBusHitraceChainEnd();
1849 return;
1850 }
1851
1852 info->peerId = msg->msgHead.peerId;
1853 info->myId = msg->msgHead.myId;
1854
1855 if (TransProxyGetAppInfoById(info->myId, &(info->appInfo)) != SOFTBUS_OK) {
1856 TRANS_LOGE(TRANS_CTRL, "fail to get peer data info");
1857 SoftBusFree(info);
1858 SoftBusHitraceChainEnd();
1859 return;
1860 }
1861
1862 if (TransProxyGetReqIdAndStatus(info->myId, &info->reqId, &info->status) != SOFTBUS_OK) {
1863 TRANS_LOGE(TRANS_CTRL, "fail to get conn reqId");
1864 goto EXIT;
1865 }
1866
1867 if (CheckAppTypeAndMsgHead(&msg->msgHead, &info->appInfo) != SOFTBUS_OK) {
1868 TRANS_LOGE(TRANS_CTRL, "only auth channel surpport plain text data");
1869 goto EXIT;
1870 }
1871
1872 if (info->status == PROXY_CHANNEL_STATUS_HANDSHAKEING &&
1873 (msg->msgHead.cipher & AUTH_SINGLE_CIPHER) == AUTH_SINGLE_CIPHER &&
1874 TransProxyProcessReNegotiateMsg(msg, info) == SOFTBUS_OK) {
1875 goto EXIT;
1876 }
1877
1878 if (TransProxyResetChan(info) != SOFTBUS_OK) {
1879 TRANS_LOGE(TRANS_CTRL, "reset chan fail mychannelId=%{public}d, peerChannelId=%{public}d", msg->msgHead.myId,
1880 msg->msgHead.peerId);
1881 goto EXIT;
1882 }
1883
1884 TransProxyProcessResetMsgHelper(info, msg);
1885 EXIT:
1886 (void)memset_s(info->appInfo.sessionKey, sizeof(info->appInfo.sessionKey), 0, sizeof(info->appInfo.sessionKey));
1887 SoftBusFree(info);
1888 SoftBusHitraceChainEnd();
1889 return;
1890 }
1891
TransProxyProcessKeepAlive(const ProxyMessage * msg)1892 void TransProxyProcessKeepAlive(const ProxyMessage *msg)
1893 {
1894 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1895 if (info == NULL) {
1896 TRANS_LOGE(TRANS_CTRL, "ProxyProcessKeepAlive calloc failed.");
1897 return;
1898 }
1899
1900 TRANS_LOGI(TRANS_CTRL, "recv keepalive myChannelId=%{public}d, peerChannelId=%{public}d", msg->msgHead.myId,
1901 msg->msgHead.peerId);
1902 if (TransProxyUnpackIdentity(msg->data, info->identity, sizeof(info->identity), msg->dataLen) != SOFTBUS_OK) {
1903 TRANS_LOGE(TRANS_CTRL, "keep alive unpack identity fail");
1904 SoftBusFree(info);
1905 return;
1906 }
1907 info->peerId = msg->msgHead.peerId;
1908 info->myId = msg->msgHead.myId;
1909
1910 if (TransProxyKeepAliveChan(info) != SOFTBUS_OK) {
1911 TRANS_LOGE(TRANS_CTRL, "reset keep alive proc fail myChannelId=%{public}d, peerChannelId=%{public}d",
1912 msg->msgHead.myId, msg->msgHead.peerId);
1913 SoftBusFree(info);
1914 return;
1915 }
1916
1917 TransProxyAckKeepalive(info);
1918 (void)memset_s(info->appInfo.sessionKey, sizeof(info->appInfo.sessionKey), 0, sizeof(info->appInfo.sessionKey));
1919 SoftBusFree(info);
1920 }
1921
TransProxyProcessKeepAliveAck(const ProxyMessage * msg)1922 void TransProxyProcessKeepAliveAck(const ProxyMessage *msg)
1923 {
1924 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1925 if (info == NULL) {
1926 TRANS_LOGE(TRANS_CTRL, "ProxyProcessKeepAliveAck calloc failed.");
1927 return;
1928 }
1929
1930 TRANS_LOGI(TRANS_CTRL, "recv keepalive ack myChannelId=%{public}d, peerChannelId=%{public}d", msg->msgHead.myId,
1931 msg->msgHead.peerId);
1932 if (TransProxyUnpackIdentity(msg->data, info->identity, sizeof(info->identity), msg->dataLen) != SOFTBUS_OK) {
1933 SoftBusFree(info);
1934 return;
1935 }
1936 info->peerId = msg->msgHead.peerId;
1937 info->myId = msg->msgHead.myId;
1938
1939 if (TransProxyKeepAliveChan(info) != SOFTBUS_OK) {
1940 TRANS_LOGE(TRANS_CTRL, "reset keep alive ack proc fail myChannelId=%{public}d, peerChannelId=%{public}d",
1941 msg->msgHead.myId, msg->msgHead.peerId);
1942 SoftBusFree(info);
1943 return;
1944 }
1945 (void)memset_s(info->appInfo.sessionKey, sizeof(info->appInfo.sessionKey), 0, sizeof(info->appInfo.sessionKey));
1946 SoftBusFree(info);
1947 }
1948
TransProxyProcessDataRecv(const ProxyMessage * msg)1949 void TransProxyProcessDataRecv(const ProxyMessage *msg)
1950 {
1951 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1952 if (info == NULL) {
1953 TRANS_LOGE(TRANS_CTRL, "ProxyProcessDataRecv calloc failed.");
1954 return;
1955 }
1956
1957 if (TransProxyGetRecvMsgChanInfo(msg->msgHead.myId, msg->msgHead.peerId, info) != SOFTBUS_OK) {
1958 TRANS_LOGE(TRANS_CTRL, "data recv get info fail myChannelId=%{public}d, peerChannelId=%{public}d",
1959 msg->msgHead.myId, msg->msgHead.peerId);
1960 SoftBusFree(info);
1961 return;
1962 }
1963
1964 OnProxyChannelMsgReceived(info->channelId, &(info->appInfo), msg->data, msg->dataLen);
1965 (void)memset_s(info->appInfo.sessionKey, sizeof(info->appInfo.sessionKey), 0, sizeof(info->appInfo.sessionKey));
1966 SoftBusFree(info);
1967 }
1968
TransProxyOnMessageReceived(const ProxyMessage * msg)1969 void TransProxyOnMessageReceived(const ProxyMessage *msg)
1970 {
1971 if (msg == NULL) {
1972 return;
1973 }
1974 switch (msg->msgHead.type) {
1975 case PROXYCHANNEL_MSG_TYPE_HANDSHAKE: {
1976 TransProxyProcessHandshakeMsg(msg);
1977 break;
1978 }
1979 case PROXYCHANNEL_MSG_TYPE_HANDSHAKE_ACK: {
1980 TransProxyProcessHandshakeAckMsg(msg);
1981 break;
1982 }
1983 case PROXYCHANNEL_MSG_TYPE_RESET: {
1984 TransProxyProcessResetMsg(msg);
1985 break;
1986 }
1987 case PROXYCHANNEL_MSG_TYPE_KEEPALIVE: {
1988 TransProxyProcessKeepAlive(msg);
1989 break;
1990 }
1991 case PROXYCHANNEL_MSG_TYPE_KEEPALIVE_ACK: {
1992 TransProxyProcessKeepAliveAck(msg);
1993 break;
1994 }
1995 case PROXYCHANNEL_MSG_TYPE_NORMAL: {
1996 TransProxyProcessDataRecv(msg);
1997 break;
1998 }
1999 case PROXYCHANNEL_MSG_TYPE_HANDSHAKE_AUTH: {
2000 TransProxyProcessHandshakeAuthMsg(msg);
2001 break;
2002 }
2003 default: {
2004 break;
2005 }
2006 }
2007 }
2008
CopyAppInfoFastTransData(ProxyChannelInfo * chan,const AppInfo * appInfo)2009 static int32_t CopyAppInfoFastTransData(ProxyChannelInfo *chan, const AppInfo *appInfo)
2010 {
2011 if (appInfo->fastTransData != NULL && appInfo->fastTransDataSize > 0) {
2012 uint8_t *fastTransData = (uint8_t *)SoftBusCalloc(appInfo->fastTransDataSize);
2013 if (fastTransData == NULL) {
2014 return SOFTBUS_MALLOC_ERR;
2015 }
2016 if (memcpy_s((char *)fastTransData, appInfo->fastTransDataSize, (const char *)appInfo->fastTransData,
2017 appInfo->fastTransDataSize) != EOK) {
2018 TRANS_LOGE(TRANS_CTRL, "memcpy fastTransData fail");
2019 SoftBusFree(fastTransData);
2020 return SOFTBUS_MEM_ERR;
2021 }
2022 chan->appInfo.fastTransData = fastTransData;
2023 }
2024 return SOFTBUS_OK;
2025 }
2026
TransProxyCreateChanInfo(ProxyChannelInfo * chan,int32_t channelId,const AppInfo * appInfo)2027 int32_t TransProxyCreateChanInfo(ProxyChannelInfo *chan, int32_t channelId, const AppInfo *appInfo)
2028 {
2029 chan->myId = (int16_t)channelId;
2030 chan->channelId = channelId;
2031
2032 int32_t ret = GenerateRandomStr(chan->identity, sizeof(chan->identity));
2033 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "GenerateRandomStr err");
2034
2035 if (appInfo->appType != APP_TYPE_AUTH) {
2036 ret = SoftBusGenerateRandomArray((unsigned char *)appInfo->sessionKey, sizeof(appInfo->sessionKey));
2037 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "GenerateRandomArray err");
2038 }
2039
2040 if (memcpy_s(&(chan->appInfo), sizeof(chan->appInfo), appInfo, sizeof(AppInfo)) != EOK) {
2041 TRANS_LOGE(TRANS_CTRL, "appInfo memcpy failed.");
2042 return SOFTBUS_MEM_ERR;
2043 }
2044
2045 ret = CopyAppInfoFastTransData(chan, appInfo);
2046 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "copy appinfo fast trans data fail");
2047
2048 ret = TransProxyAddChanItem(chan);
2049 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
2050 TRANS_CTRL, "trans proxy add channelId fail. channelId=%{public}d", channelId);
2051 return SOFTBUS_OK;
2052 }
2053
TransProxyCreatePagingChanInfo(ProxyChannelInfo * chan)2054 int32_t TransProxyCreatePagingChanInfo(ProxyChannelInfo *chan)
2055 {
2056 TRANS_CHECK_AND_RETURN_RET_LOGE(chan != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL, "channel info is null");
2057 int32_t ret = TransProxyAddChanItem(chan);
2058 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
2059 TRANS_CTRL, "trans proxy add channelId fail. channelId=%{public}d", chan->channelId);
2060 return SOFTBUS_OK;
2061 }
2062
TransProxyUpdateBlePriority(int32_t channelId,uint32_t connId,BlePriority priority)2063 static void TransProxyUpdateBlePriority(int32_t channelId, uint32_t connId, BlePriority priority)
2064 {
2065 if (priority <= BLE_PRIORITY_DEFAULT || priority >= BLE_PRIORITY_MAX) {
2066 TRANS_LOGD(TRANS_CTRL, "not need updated ble priority");
2067 return;
2068 }
2069 ConnectBlePriority blePriority = CONN_BLE_PRIORITY_BALANCED;
2070 switch (priority) {
2071 case BLE_PRIORITY_BALANCED:
2072 blePriority = CONN_BLE_PRIORITY_BALANCED;
2073 break;
2074 case BLE_PRIORITY_HIGH:
2075 blePriority = CONN_BLE_PRIORITY_HIGH;
2076 break;
2077 case BLE_PRIORITY_LOW_POWER:
2078 blePriority = CONN_BLE_PRIORITY_LOW_POWER;
2079 break;
2080 default:
2081 return;
2082 }
2083 UpdateOption option = {
2084 .type = CONNECT_BLE,
2085 .bleOption = {
2086 .priority = blePriority,
2087 }
2088 };
2089 int32_t ret = ConnUpdateConnection(connId, &option);
2090 TRANS_LOGI(TRANS_CTRL, "update ble priority. channelId=%{public}d, connId=%{public}u, "
2091 "blePriority=%{public}d, ret=%{public}d", channelId, connId, priority, ret);
2092 }
2093
TransProxyOpenProxyChannelSuccess(int32_t channelId)2094 void TransProxyOpenProxyChannelSuccess(int32_t channelId)
2095 {
2096 SoftBusHitraceChainBegin("TransProxyOpenProxyChannelSuccess");
2097 TRANS_LOGI(TRANS_CTRL, "send handshake msg. channelId=%{public}d", channelId);
2098 ProxyChannelInfo *channelInfo = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
2099 if (channelInfo == NULL) {
2100 TRANS_LOGE(TRANS_CTRL, "malloc proxyChannelInfo failed");
2101 SoftBusHitraceChainEnd();
2102 return;
2103 }
2104 if (TransProxyGetChanByChanId(channelId, channelInfo) != SOFTBUS_OK) {
2105 SoftBusFree(channelInfo);
2106 TRANS_LOGE(TRANS_CTRL, "disconnect device channelId=%{public}d", channelId);
2107 SoftBusHitraceChainEnd();
2108 return;
2109 }
2110 if (channelInfo->type == CONNECT_BLE) {
2111 TransProxyUpdateBlePriority(channelId, channelInfo->connId, channelInfo->appInfo.blePriority);
2112 }
2113 (void)memset_s(channelInfo->appInfo.sessionKey, sizeof(channelInfo->appInfo.sessionKey), 0,
2114 sizeof(channelInfo->appInfo.sessionKey));
2115 AuthConnInfo authConnInfo;
2116 (void)memset_s(&authConnInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
2117 int32_t ret = GetAuthConnInfoByConnId(channelInfo->connId, &authConnInfo);
2118 if (ret != SOFTBUS_OK) {
2119 TRANS_LOGE(TRANS_CTRL, "get authConnInfo by connId=%{public}u fail, ret=%{public}d", channelInfo->connId, ret);
2120 SoftBusFree(channelInfo);
2121 SoftBusHitraceChainEnd();
2122 return;
2123 }
2124
2125 char peerNetworkId[DEVICE_ID_SIZE_MAX] = { 0 };
2126 ret = TransGetRemoteDeviceIdByReqId(channelInfo->reqId, peerNetworkId);
2127 SoftBusFree(channelInfo);
2128 if (ret != SOFTBUS_OK) {
2129 TRANS_LOGE(TRANS_CTRL, "get networkId failed, ret=%{public}d", ret);
2130 SoftBusHitraceChainEnd();
2131 return;
2132 }
2133
2134 ret = TransNegotiateSessionKey(&authConnInfo, channelId, peerNetworkId);
2135 if (ret != SOFTBUS_OK) {
2136 TransProxyNegoSessionKeyFail(channelId, ret);
2137 TRANS_LOGE(TRANS_CTRL, "generate session key failed ret=%{public}d", ret);
2138 SoftBusHitraceChainEnd();
2139 return;
2140 }
2141 SoftBusHitraceChainEnd();
2142 }
2143
TransProxyOpenProxyChannelFail(int32_t channelId,const AppInfo * appInfo,int32_t errCode)2144 void TransProxyOpenProxyChannelFail(int32_t channelId, const AppInfo *appInfo, int32_t errCode)
2145 {
2146 SoftBusHitraceChainBegin("TransProxyOpenProxyChannelFail");
2147 if (errCode == SOFTBUS_TRANS_PEER_SESSION_NOT_CREATED) {
2148 (void)TransAddTimestampToList(
2149 appInfo->myData.sessionName, appInfo->peerData.sessionName, appInfo->peerNetWorkId, SoftBusGetSysTimeMs());
2150 }
2151 (void)OnProxyChannelOpenFailed(channelId, appInfo, errCode);
2152 SoftBusHitraceChainEnd();
2153 }
2154
TransProxyOpenProxyChannel(AppInfo * appInfo,const ConnectOption * connInfo,int32_t * channelId)2155 int32_t TransProxyOpenProxyChannel(AppInfo *appInfo, const ConnectOption *connInfo,
2156 int32_t *channelId)
2157 {
2158 if (appInfo == NULL || connInfo == NULL || channelId == NULL) {
2159 TRANS_LOGE(TRANS_CTRL, "open normal channel: invalid para");
2160 return SOFTBUS_INVALID_PARAM;
2161 }
2162
2163 SelectRouteType(connInfo->type, &appInfo->routeType);
2164 return TransProxyOpenConnChannel(appInfo, connInfo, channelId);
2165 }
2166
TransProxyCloseProxyChannel(int32_t channelId)2167 int32_t TransProxyCloseProxyChannel(int32_t channelId)
2168 {
2169 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
2170 if (info == NULL) {
2171 return SOFTBUS_MALLOC_ERR;
2172 }
2173
2174 if (TransProxyDelByChannelId(channelId, info) != SOFTBUS_OK) {
2175 TRANS_LOGE(TRANS_CTRL, "proxy del failed. channelId=%{public}d", channelId);
2176 SoftBusFree(info);
2177 return SOFTBUS_TRANS_PROXY_INVALID_CHANNEL_ID;
2178 }
2179 if (info->type == CONNECT_BLE && info->appInfo.blePriority > BLE_PRIORITY_BALANCED &&
2180 info->appInfo.blePriority < BLE_PRIORITY_MAX) {
2181 TransProxyUpdateBlePriority(channelId, info->connId, BLE_PRIORITY_BALANCED);
2182 }
2183 (void)memset_s(info->appInfo.sessionKey, sizeof(info->appInfo.sessionKey), 0, sizeof(info->appInfo.sessionKey));
2184 TransProxyPostResetPeerMsgToLoop(info);
2185 return SOFTBUS_OK;
2186 }
2187
TransProxyTimerItemProc(const ListNode * proxyProcList)2188 static void TransProxyTimerItemProc(const ListNode *proxyProcList)
2189 {
2190 if (IsListEmpty(proxyProcList)) {
2191 return;
2192 }
2193 TRANS_LOGI(TRANS_CTRL, "enter.");
2194 ProxyChannelInfo *removeNode = NULL;
2195 ProxyChannelInfo *nextNode = NULL;
2196 ProxyChannelInfo *disChanInfo = NULL;
2197 uint32_t connId;
2198 int8_t status;
2199 bool isServer;
2200
2201 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, proxyProcList, ProxyChannelInfo, node) {
2202 ListDelete(&(removeNode->node));
2203 status = removeNode->status;
2204 SoftBusFree((void *)removeNode->appInfo.fastTransData);
2205 removeNode->appInfo.fastTransData = NULL;
2206 (void)memset_s(removeNode->appInfo.sessionKey, sizeof(removeNode->appInfo.sessionKey), 0,
2207 sizeof(removeNode->appInfo.sessionKey));
2208 if (status == PROXY_CHANNEL_STATUS_HANDSHAKE_TIMEOUT) {
2209 connId = removeNode->connId;
2210 isServer = removeNode->isServer;
2211 disChanInfo = (ProxyChannelInfo *)SoftBusMalloc(sizeof(ProxyChannelInfo));
2212 if (disChanInfo == NULL) {
2213 SoftBusFree(removeNode);
2214 TRANS_LOGE(TRANS_SVC, "SoftBusMalloc failed");
2215 return;
2216 }
2217 if (memcpy_s(disChanInfo, sizeof(ProxyChannelInfo), removeNode, sizeof(ProxyChannelInfo)) != EOK) {
2218 SoftBusFree(removeNode);
2219 SoftBusFree(disChanInfo);
2220 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
2221 return;
2222 }
2223 TransProxyPostOpenFailMsgToLoop(removeNode, SOFTBUS_TRANS_HANDSHAKE_TIMEOUT);
2224 TransProxyPostDisConnectMsgToLoop(connId, isServer, disChanInfo);
2225 } else if (status == PROXY_CHANNEL_STATUS_CONNECTING_TIMEOUT) {
2226 (void)TransDelConnByReqId(removeNode->reqId);
2227 TransProxyPostOpenFailMsgToLoop(removeNode, SOFTBUS_TRANS_HANDSHAKE_TIMEOUT);
2228 } else if (status == PROXY_CHANNEL_STATUS_TIMEOUT) {
2229 TRANS_LOGI(TRANS_CTRL, "send keepalive channelId=%{public}d", removeNode->myId);
2230 TransProxyPostKeepAliveMsgToLoop(removeNode);
2231 } else {
2232 SoftBusFree(removeNode);
2233 }
2234 }
2235 }
2236
TransProxyTimerProc(void)2237 void TransProxyTimerProc(void)
2238 {
2239 ProxyChannelInfo *removeNode = NULL;
2240 ProxyChannelInfo *nextNode = NULL;
2241 ListNode proxyProcList;
2242 int32_t timeout = 0;
2243
2244 TRANS_CHECK_AND_RETURN_LOGE(
2245 g_proxyChannelList != NULL, TRANS_CTRL, "g_proxyChannelList is null");
2246 TRANS_CHECK_AND_RETURN_LOGE(
2247 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, TRANS_CTRL, "lock mutex fail!");
2248 if (g_proxyChannelList->cnt <= 0) {
2249 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2250 return;
2251 }
2252
2253 ListInit(&proxyProcList);
2254 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
2255 removeNode->timeout++;
2256 if (removeNode->status == PROXY_CHANNEL_STATUS_HANDSHAKEING ||
2257 removeNode->status == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
2258 timeout = removeNode->isD2D ? D2D_CHANNEL_CONTROL_TIMEOUT : PROXY_CHANNEL_CONTROL_TIMEOUT;
2259 if (removeNode->timeout >= timeout) {
2260 removeNode->status = (removeNode->status == PROXY_CHANNEL_STATUS_HANDSHAKEING) ?
2261 PROXY_CHANNEL_STATUS_HANDSHAKE_TIMEOUT : PROXY_CHANNEL_STATUS_CONNECTING_TIMEOUT;
2262 TRANS_LOGE(TRANS_CTRL, "handshake is timeout. channelId=%{public}d", removeNode->myId);
2263 ReleaseProxyChannelId(removeNode->channelId);
2264 ListDelete(&(removeNode->node));
2265 ListAdd(&proxyProcList, &(removeNode->node));
2266 g_proxyChannelList->cnt--;
2267 }
2268 }
2269 if (removeNode->status == PROXY_CHANNEL_STATUS_KEEPLIVEING) {
2270 if (removeNode->timeout >= PROXY_CHANNEL_CONTROL_TIMEOUT) {
2271 removeNode->status = PROXY_CHANNEL_STATUS_TIMEOUT;
2272 TRANS_LOGE(TRANS_CTRL, "keepalvie is timeout. channelId=%{public}d", removeNode->myId);
2273 ReleaseProxyChannelId(removeNode->channelId);
2274 ListDelete(&(removeNode->node));
2275 ListAdd(&proxyProcList, &(removeNode->node));
2276 g_proxyChannelList->cnt--;
2277 }
2278 }
2279 }
2280 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2281 TransProxyTimerItemProc(&proxyProcList);
2282 }
2283
TransWifiOnLineProc(const char * peerNetworkId)2284 static void TransWifiOnLineProc(const char *peerNetworkId)
2285 {
2286 TRANS_LOGI(TRANS_CTRL, "wifi is online");
2287 if (peerNetworkId == NULL) {
2288 TRANS_LOGE(TRANS_CTRL, "invalid networkId");
2289 return;
2290 }
2291 int32_t ret = NotifyNearByOnMigrateEvents(peerNetworkId, WIFI_STA, true);
2292 if (ret == SOFTBUS_OK) {
2293 TRANS_LOGI(TRANS_CTRL, "notify upgrade migrate success");
2294 return;
2295 }
2296 TRANS_LOGE(TRANS_CTRL, "notify upgrade migrate fail");
2297 }
2298
TransWifiOffLineProc(const char * peerNetworkId)2299 static void TransWifiOffLineProc(const char *peerNetworkId)
2300 {
2301 TRANS_LOGI(TRANS_CTRL, "wifi is offline");
2302 if (peerNetworkId == NULL) {
2303 TRANS_LOGE(TRANS_CTRL, "invalid networkId");
2304 return;
2305 }
2306 int32_t ret = NotifyNearByOnMigrateEvents(peerNetworkId, WIFI_STA, false);
2307 if (ret == SOFTBUS_OK) {
2308 TRANS_LOGI(TRANS_CTRL, "notify degrade migrate success");
2309 return;
2310 }
2311 TRANS_LOGE(TRANS_CTRL, "notify degrade migrate fail");
2312 }
2313
TransWifiStateChange(const LnnEventBasicInfo * info)2314 void TransWifiStateChange(const LnnEventBasicInfo *info)
2315 {
2316 TRANS_LOGI(TRANS_CTRL, "Start");
2317 if ((info == NULL) || (info->event != LNN_EVENT_NODE_MIGRATE)) {
2318 return;
2319 }
2320
2321 LnnOnlineStateEventInfo *onlineStateInfo = (LnnOnlineStateEventInfo *)info;
2322 if (onlineStateInfo->isOnline == true) {
2323 TransWifiOnLineProc(onlineStateInfo->networkId);
2324 } else {
2325 TransWifiOffLineProc(onlineStateInfo->networkId);
2326 }
2327 }
2328
TransNotifySingleNetworkOffLine(const LnnEventBasicInfo * info)2329 static void TransNotifySingleNetworkOffLine(const LnnEventBasicInfo *info)
2330 {
2331 if ((info == NULL) || (info->event != LNN_EVENT_SINGLE_NETWORK_OFFLINE)) {
2332 return;
2333 }
2334 LnnSingleNetworkOffLineEvent *offlineInfo = (LnnSingleNetworkOffLineEvent *)info;
2335 ConnectionAddrType type = offlineInfo->type;
2336 if (type == CONNECTION_ADDR_WLAN) {
2337 TransOnLinkDown(offlineInfo->networkId, offlineInfo->uuid, offlineInfo->udid, "", WIFI_STA);
2338 } else if (type == CONNECTION_ADDR_BLE) {
2339 TransOnLinkDown(offlineInfo->networkId, offlineInfo->uuid, offlineInfo->udid, "", BT_BLE);
2340 } else if (type == CONNECTION_ADDR_BR) {
2341 TransOnLinkDown(offlineInfo->networkId, offlineInfo->uuid, offlineInfo->udid, "", BT_BR);
2342 } else if (type == CONNECTION_ADDR_NCM) {
2343 TransOnLinkDown(offlineInfo->networkId, offlineInfo->uuid, offlineInfo->udid, "", WIFI_USB);
2344 } else if (type == CONNECTION_ADDR_SLE) {
2345 TransOnLinkDown(offlineInfo->networkId, offlineInfo->uuid, offlineInfo->udid, "", BT_SLE);
2346 }
2347 }
2348
TransNotifyOffLine(const LnnEventBasicInfo * info)2349 static void TransNotifyOffLine(const LnnEventBasicInfo *info)
2350 {
2351 TRANS_LOGI(TRANS_CTRL, "Trans Notify OffLine Start");
2352 if ((info == NULL) || (info->event != LNN_EVENT_NODE_ONLINE_STATE_CHANGED)) {
2353 return;
2354 }
2355 LnnOnlineStateEventInfo *onlineStateInfo = (LnnOnlineStateEventInfo *)info;
2356 if (onlineStateInfo->isOnline) {
2357 return;
2358 }
2359
2360 TransOnLinkDown(onlineStateInfo->networkId, onlineStateInfo->uuid, onlineStateInfo->udid, "", WIFI_P2P);
2361 TransOnLinkDown(onlineStateInfo->networkId, onlineStateInfo->uuid, onlineStateInfo->udid, "", WIFI_STA);
2362 TransOnLinkDown(onlineStateInfo->networkId, onlineStateInfo->uuid, onlineStateInfo->udid, "", BT_BR);
2363 TransOnLinkDown(onlineStateInfo->networkId, onlineStateInfo->uuid, onlineStateInfo->udid, "", BT_BLE);
2364 TransOnLinkDown(onlineStateInfo->networkId, onlineStateInfo->uuid, onlineStateInfo->udid, "", WIFI_USB);
2365 TransOnLinkDown(onlineStateInfo->networkId, onlineStateInfo->uuid, onlineStateInfo->udid, "", BT_SLE);
2366 }
2367
TransNotifyUserSwitch(const LnnEventBasicInfo * info)2368 static void TransNotifyUserSwitch(const LnnEventBasicInfo *info)
2369 {
2370 #define USER_SWITCH_OFFSET 10
2371 TRANS_CHECK_AND_RETURN_LOGE(info != NULL, TRANS_CTRL, "invalid Lnn info");
2372 const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
2373 SoftBusUserSwitchState userSwitchState = (SoftBusUserSwitchState)event->status;
2374 switch (userSwitchState) {
2375 case SOFTBUS_USER_SWITCHED: {
2376 TransOnLinkDown("", "", "", "", ROUTE_TYPE_ALL | 1 << USER_SWITCH_OFFSET);
2377 break;
2378 }
2379 case SOFTBUS_USER_SWITCH_UNKNOWN:
2380 default: {
2381 TRANS_LOGE(TRANS_CTRL, "recv unknow user switch event, state=%{public}u", event->status);
2382 break;
2383 }
2384 }
2385 }
2386
TransProxyManagerInitInner(const IServerChannelCallBack * cb)2387 static int32_t TransProxyManagerInitInner(const IServerChannelCallBack *cb)
2388 {
2389 int32_t ret = TransProxySetCallBack(cb);
2390 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "TransProxySetCallBack fail");
2391
2392 g_proxyChannelList = CreateSoftBusList();
2393 if (g_proxyChannelList == NULL) {
2394 TRANS_LOGE(TRANS_INIT, "proxy manager init inner failed");
2395 return SOFTBUS_MALLOC_ERR;
2396 }
2397 return SOFTBUS_OK;
2398 }
2399
TransProxyManagerInit(const IServerChannelCallBack * cb)2400 int32_t TransProxyManagerInit(const IServerChannelCallBack *cb)
2401 {
2402 int32_t ret = TransProxyManagerInitInner(cb);
2403 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "init proxy manager failed");
2404
2405 ret = TransProxyTransInit();
2406 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "TransProxyTransInit fail");
2407
2408 ret = RegisterTimeoutCallback(SOFTBUS_PROXYCHANNEL_TIMER_FUN, TransProxyTimerProc);
2409 if (ret != SOFTBUS_OK) {
2410 DestroySoftBusList(g_proxyChannelList);
2411 g_proxyChannelList = NULL;
2412 TRANS_LOGE(TRANS_INIT, "trans proxy register timeout callback failed.");
2413 return ret;
2414 }
2415
2416 ret = LnnRegisterEventHandler(LNN_EVENT_SINGLE_NETWORK_OFFLINE, TransNotifySingleNetworkOffLine);
2417 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
2418 TRANS_INIT, "register TransNotifySingleNetworkOffLine failed.");
2419
2420 ret = LnnRegisterEventHandler(LNN_EVENT_NODE_ONLINE_STATE_CHANGED, TransNotifyOffLine);
2421 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "register TransNotifyOffLine failed.");
2422
2423 ret = LnnRegisterEventHandler(LNN_EVENT_NODE_MIGRATE, TransWifiStateChange);
2424 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "TransWifiStateChange register failed.");
2425
2426 ret = LnnRegisterEventHandler(LNN_EVENT_USER_SWITCHED, TransNotifyUserSwitch);
2427 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "register user switch event failed.");
2428
2429 TRANS_LOGI(TRANS_INIT, "proxy channel init ok");
2430 return SOFTBUS_OK;
2431 }
2432
TransProxyGetNameByChanId(int32_t chanId,char * pkgName,char * sessionName,uint16_t pkgLen,uint16_t sessionLen)2433 int32_t TransProxyGetNameByChanId(int32_t chanId, char *pkgName, char *sessionName,
2434 uint16_t pkgLen, uint16_t sessionLen)
2435 {
2436 TRANS_CHECK_AND_RETURN_RET_LOGE((pkgName != NULL && sessionName != NULL), SOFTBUS_INVALID_PARAM, TRANS_CTRL,
2437 "invalid param");
2438 ProxyChannelInfo *chan = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
2439 TRANS_CHECK_AND_RETURN_RET_LOGE(chan != NULL, SOFTBUS_MALLOC_ERR, TRANS_CTRL, "malloc err");
2440 int32_t ret = TransProxyGetChanByChanId(chanId, chan);
2441 (void)memset_s(chan->appInfo.sessionKey, sizeof(chan->appInfo.sessionKey), 0, sizeof(chan->appInfo.sessionKey));
2442 if (ret != SOFTBUS_OK) {
2443 TRANS_LOGE(TRANS_CTRL, "get channel info by chanId failed. chanId=%{public}d", chanId);
2444 SoftBusFree(chan);
2445 return ret;
2446 }
2447 ret = TransProxyGetPkgName(chan->appInfo.myData.sessionName, pkgName, pkgLen);
2448 if (ret != SOFTBUS_OK) {
2449 TRANS_LOGE(TRANS_CTRL, "get pkgName failed");
2450 SoftBusFree(chan);
2451 return ret;
2452 }
2453 if (strcpy_s(sessionName, sessionLen, chan->appInfo.myData.sessionName) != EOK) {
2454 TRANS_LOGE(TRANS_CTRL, "strcpy_s failed");
2455 SoftBusFree(chan);
2456 return SOFTBUS_STRCPY_ERR;
2457 }
2458 SoftBusFree(chan);
2459 return SOFTBUS_OK;
2460 }
2461
TransProxyManagerDeinitInner(void)2462 static void TransProxyManagerDeinitInner(void)
2463 {
2464 TRANS_CHECK_AND_RETURN_LOGE(
2465 g_proxyChannelList != NULL, TRANS_INIT, "g_proxyChannelList is null");
2466 TRANS_CHECK_AND_RETURN_LOGE(
2467 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, TRANS_INIT, "lock mutex fail!");
2468 ProxyChannelInfo *item = NULL;
2469 ProxyChannelInfo *nextNode = NULL;
2470 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
2471 ReleaseProxyChannelId(item->channelId);
2472 ListDelete(&(item->node));
2473 if (item->appInfo.fastTransData != NULL) {
2474 SoftBusFree((void *)item->appInfo.fastTransData);
2475 }
2476 SoftBusFree(item);
2477 }
2478 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2479
2480 DestroySoftBusList(g_proxyChannelList);
2481 g_proxyChannelList = NULL;
2482 }
2483
TransProxyManagerDeinit(void)2484 void TransProxyManagerDeinit(void)
2485 {
2486 if (UnRegisterTimeoutCallback(SOFTBUS_PROXYCHANNEL_TIMER_FUN) != SOFTBUS_OK) {
2487 TRANS_LOGE(TRANS_CTRL, "unregister timeout callback failed");
2488 }
2489 TransProxyManagerDeinitInner();
2490 }
2491
TransProxyDestroyChannelList(const ListNode * destroyList)2492 static void TransProxyDestroyChannelList(const ListNode *destroyList)
2493 {
2494 TRANS_LOGD(TRANS_CTRL, "enter.");
2495 TRANS_CHECK_AND_RETURN_LOGE(
2496 (destroyList != NULL && !IsListEmpty(destroyList)), TRANS_INIT, "destroyList is null");
2497 ProxyChannelInfo *destroyNode = NULL;
2498 ProxyChannelInfo *nextDestroyNode = NULL;
2499 LIST_FOR_EACH_ENTRY_SAFE(destroyNode, nextDestroyNode, destroyList, ProxyChannelInfo, node) {
2500 ListDelete(&(destroyNode->node));
2501 TransProxyResetPeer(destroyNode);
2502 TransProxyCloseConnChannel(destroyNode->connId, destroyNode->isServer);
2503 if (destroyNode->appInfo.fastTransData != NULL) {
2504 SoftBusFree((void *)destroyNode->appInfo.fastTransData);
2505 }
2506 (void)memset_s(destroyNode->appInfo.sessionKey, sizeof(destroyNode->appInfo.sessionKey), 0,
2507 sizeof(destroyNode->appInfo.sessionKey));
2508 SoftBusFree(destroyNode);
2509 }
2510 return;
2511 }
2512
TransProxyDeathCallback(const char * pkgName,int32_t pid)2513 void TransProxyDeathCallback(const char *pkgName, int32_t pid)
2514 {
2515 TRANS_CHECK_AND_RETURN_LOGE(
2516 (pkgName != NULL && g_proxyChannelList != NULL), TRANS_CTRL, "pkgName or proxy channel list is null.");
2517 char *anonymizePkgName = NULL;
2518 Anonymize(pkgName, &anonymizePkgName);
2519 TRANS_LOGW(TRANS_CTRL, "pkgName=%{public}s, pid=%{public}d", AnonymizeWrapper(anonymizePkgName), pid);
2520 AnonymizeFree(anonymizePkgName);
2521 ListNode destroyList;
2522 ListInit(&destroyList);
2523 ProxyChannelInfo *item = NULL;
2524 ProxyChannelInfo *nextNode = NULL;
2525 if (SoftBusMutexLock(&g_proxyChannelList->lock) != SOFTBUS_OK) {
2526 TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
2527 return;
2528 }
2529 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
2530 if ((strcmp(item->appInfo.myData.pkgName, pkgName) == 0) && (item->appInfo.myData.pid == pid)) {
2531 ReleaseProxyChannelId(item->channelId);
2532 ListDelete(&(item->node));
2533 g_proxyChannelList->cnt--;
2534 ListAdd(&destroyList, &(item->node));
2535 TRANS_LOGI(TRANS_CTRL, "add channelId=%{public}d", item->channelId);
2536 }
2537 }
2538 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2539 TransProxyDestroyChannelList(&destroyList);
2540 TRANS_LOGD(TRANS_CTRL, "ok");
2541 }
2542
TransProxyCloseChannelByRequestId(uint32_t requestId)2543 void TransProxyCloseChannelByRequestId(uint32_t requestId)
2544 {
2545 TRANS_LOGI(TRANS_CTRL, "close channel by reqId=%{public}d", requestId);
2546 ListNode destroyList;
2547 ListInit(&destroyList);
2548 ProxyChannelInfo *item = NULL;
2549 ProxyChannelInfo *nextNode = NULL;
2550 if (SoftBusMutexLock(&g_proxyChannelList->lock) != SOFTBUS_OK) {
2551 TRANS_LOGI(TRANS_CTRL, "lock mutex fail!");
2552 return;
2553 }
2554 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
2555 if (item->reqId == (int32_t)requestId && item->status != PROXY_CHANNEL_STATUS_COMPLETED) {
2556 ReleaseProxyChannelId(item->channelId);
2557 ListDelete(&(item->node));
2558 g_proxyChannelList->cnt--;
2559 ListAdd(&destroyList, &(item->node));
2560 TRANS_LOGI(TRANS_CTRL, "add destroy channelId=%{public}d", item->channelId);
2561 }
2562 }
2563 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2564 TransProxyDestroyChannelList(&destroyList);
2565 }
2566
TransProxyGetAppInfoByChanId(int32_t chanId,AppInfo * appInfo)2567 int32_t TransProxyGetAppInfoByChanId(int32_t chanId, AppInfo *appInfo)
2568 {
2569 TRANS_CHECK_AND_RETURN_RET_LOGE(appInfo != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL,
2570 "invalid param");
2571
2572 ProxyChannelInfo *item = NULL;
2573 ProxyChannelInfo *nextNode = NULL;
2574
2575 TRANS_CHECK_AND_RETURN_RET_LOGE(
2576 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
2577 TRANS_CHECK_AND_RETURN_RET_LOGE(
2578 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
2579
2580 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
2581 if (item->channelId == chanId) {
2582 if (memcpy_s(appInfo, sizeof(AppInfo), &item->appInfo, sizeof(AppInfo)) != EOK) {
2583 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2584 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
2585 return SOFTBUS_MEM_ERR;
2586 }
2587 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2588 return SOFTBUS_OK;
2589 }
2590 }
2591 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2592 TRANS_LOGE(TRANS_CTRL, "Proxy channel not find: channelId=%{public}d", chanId);
2593 return SOFTBUS_TRANS_NODE_NOT_FOUND;
2594 }
2595
TransProxyGetConnIdByChanId(int32_t channelId,int32_t * connId)2596 int32_t TransProxyGetConnIdByChanId(int32_t channelId, int32_t *connId)
2597 {
2598 TRANS_CHECK_AND_RETURN_RET_LOGE(connId != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL, "invalid param");
2599
2600 ProxyChannelInfo *item = NULL;
2601
2602 TRANS_CHECK_AND_RETURN_RET_LOGE(
2603 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
2604 TRANS_CHECK_AND_RETURN_RET_LOGE(
2605 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
2606
2607 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
2608 if (item->channelId == channelId) {
2609 if (item->status == PROXY_CHANNEL_STATUS_COMPLETED ||
2610 item->status == PROXY_CHANNEL_STATUS_KEEPLIVEING) {
2611 *connId = (int32_t)item->connId;
2612 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2613 return SOFTBUS_OK;
2614 } else {
2615 TRANS_LOGE(TRANS_CTRL, "g_proxyChannel status error");
2616 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2617 return SOFTBUS_TRANS_PROXY_CHANNLE_STATUS_INVALID;
2618 }
2619 }
2620 }
2621 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2622 return SOFTBUS_TRANS_NODE_NOT_FOUND;
2623 }
2624
TransProxyGetProxyChannelInfoByChannelId(int32_t channelId,ProxyChannelInfo * chan)2625 int32_t TransProxyGetProxyChannelInfoByChannelId(int32_t channelId, ProxyChannelInfo *chan)
2626 {
2627 if (g_proxyChannelList == NULL) {
2628 TRANS_LOGE(TRANS_CTRL, "g_proxyChannelList is null");
2629 return SOFTBUS_INVALID_PARAM;
2630 }
2631 TRANS_CHECK_AND_RETURN_RET_LOGE(chan != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL, "invalid param");
2632
2633 if (SoftBusMutexLock(&g_proxyChannelList->lock) != SOFTBUS_OK) {
2634 TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
2635 return SOFTBUS_LOCK_ERR;
2636 }
2637 ProxyChannelInfo *item = NULL;
2638 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
2639 if (item->channelId == channelId) {
2640 if (item->status != PROXY_CHANNEL_STATUS_COMPLETED && item->status != PROXY_CHANNEL_STATUS_KEEPLIVEING) {
2641 TRANS_LOGE(TRANS_CTRL, "invalid status=%{public}d, channelId=%{public}d", item->status, channelId);
2642 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2643 return SOFTBUS_TRANS_PROXY_CHANNLE_STATUS_INVALID;
2644 }
2645 if (memcpy_s(chan, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo)) != EOK) {
2646 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2647 TRANS_LOGE(TRANS_CTRL, "memcpy_s failed");
2648 return SOFTBUS_MEM_ERR;
2649 }
2650 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2651 return SOFTBUS_OK;
2652 }
2653 }
2654 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2655 TRANS_LOGE(TRANS_CTRL, "not found proxy channel info by channelId=%{public}d", channelId);
2656 return SOFTBUS_TRANS_NODE_NOT_FOUND;
2657 }
2658
TransProxyGetProxyChannelIdByAuthReq(uint32_t reqId,int32_t * channelId)2659 int32_t TransProxyGetProxyChannelIdByAuthReq(uint32_t reqId, int32_t *channelId)
2660 {
2661 TRANS_CHECK_AND_RETURN_RET_LOGE(g_proxyChannelList != NULL, SOFTBUS_NO_INIT,
2662 TRANS_CTRL, "g_proxyChannelList is null");
2663 TRANS_CHECK_AND_RETURN_RET_LOGE(channelId != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL, "channelId is null");
2664 TRANS_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR,
2665 TRANS_CTRL, "lock mutex fail!");
2666 ProxyChannelInfo *item = NULL;
2667 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
2668 if (item->authReqId == reqId) {
2669 *channelId = item->channelId;
2670 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2671 return SOFTBUS_OK;
2672 }
2673 }
2674 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2675 TRANS_LOGE(TRANS_CTRL, "not found proxy channel info by reqId=%{public}u", reqId);
2676 return SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND;
2677 }
2678
TransProxySetAuthHandleByChanId(int32_t channelId,AuthHandle authHandle)2679 int32_t TransProxySetAuthHandleByChanId(int32_t channelId, AuthHandle authHandle)
2680 {
2681 ProxyChannelInfo *item = NULL;
2682 ProxyChannelInfo *nextNode = NULL;
2683
2684 TRANS_CHECK_AND_RETURN_RET_LOGE(
2685 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
2686 TRANS_CHECK_AND_RETURN_RET_LOGE(
2687 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
2688
2689 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
2690 if (item->channelId == channelId) {
2691 item->authHandle.authId = authHandle.authId;
2692 item->authHandle.type = authHandle.type;
2693 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2694 return SOFTBUS_OK;
2695 }
2696 }
2697 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2698 TRANS_LOGE(TRANS_CTRL, "proxy channel not found by chanId, chanId=%{public}d", channelId);
2699 return SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND;
2700 }
2701
TransProxyGetChannelByFlag(uint32_t businessFlag,ProxyChannelInfo * chan,bool isClient)2702 int32_t TransProxyGetChannelByFlag(uint32_t businessFlag, ProxyChannelInfo *chan, bool isClient)
2703 {
2704 TRANS_CHECK_AND_RETURN_RET_LOGE(
2705 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
2706 TRANS_CHECK_AND_RETURN_RET_LOGE(
2707 chan != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL, "chan is null");
2708 TRANS_CHECK_AND_RETURN_RET_LOGE(
2709 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
2710 ProxyChannelInfo *item = NULL;
2711 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
2712 if (item->isD2D && (item->appInfo.isClient == isClient) && item->appInfo.myData.businessFlag == businessFlag) {
2713 if (memcpy_s(chan, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo)) != EOK) {
2714 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2715 TRANS_LOGE(TRANS_CTRL, "memcpy_s failed");
2716 return SOFTBUS_MEM_ERR;
2717 }
2718 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2719 return SOFTBUS_OK;
2720 }
2721 }
2722 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2723 return SOFTBUS_TRANS_NODE_NOT_FOUND;
2724 }
2725
TransProxyGetPrivilegeCloseList(ListNode * privilegeCloseList,uint64_t tokenId,int32_t pid)2726 int32_t TransProxyGetPrivilegeCloseList(ListNode *privilegeCloseList, uint64_t tokenId, int32_t pid)
2727 {
2728 if (privilegeCloseList == NULL) {
2729 TRANS_LOGE(TRANS_CTRL, "privilegeCloseList is null");
2730 return SOFTBUS_INVALID_PARAM;
2731 }
2732 TRANS_CHECK_AND_RETURN_RET_LOGE(
2733 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null");
2734 TRANS_CHECK_AND_RETURN_RET_LOGE(
2735 SoftBusMutexLock(&g_proxyChannelList->lock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
2736 ProxyChannelInfo *item = NULL;
2737 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
2738 if (item->appInfo.callingTokenId == tokenId && item->appInfo.myData.pid == pid) {
2739 (void)PrivilegeCloseListAddItem(privilegeCloseList, item->appInfo.myData.pid, item->appInfo.myData.pkgName);
2740 }
2741 }
2742 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2743 return SOFTBUS_OK;
2744 }
2745
TransProxyResetReplyCnt(int32_t channelId)2746 static int32_t TransProxyResetReplyCnt(int32_t channelId)
2747 {
2748 TRANS_CHECK_AND_RETURN_RET_LOGE(
2749 g_proxyChannelList != NULL, SOFTBUS_NO_INIT, TRANS_CTRL, "g_proxyChannelList is null.");
2750 int32_t ret = SoftBusMutexLock(&g_proxyChannelList->lock);
2751 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, TRANS_CTRL, "lock mutex fail!");
2752 ProxyChannelInfo *item = NULL;
2753 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
2754 if (item->channelId == channelId) {
2755 item->appInfo.waitOpenReplyCnt = 0;
2756 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2757 return SOFTBUS_OK;
2758 }
2759 }
2760 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
2761 TRANS_LOGE(TRANS_CTRL, "proxy channel not found by channelId=%{public}d", channelId);
2762 return SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND;
2763 }
2764
TransDealProxyCheckCollabResult(int32_t channelId,int32_t checkResult,pid_t callingPid)2765 int32_t TransDealProxyCheckCollabResult(int32_t channelId, int32_t checkResult, pid_t callingPid)
2766 {
2767 SoftBusHitraceChainBegin("TransDealProxyCheckCollabResult");
2768 int32_t dmsPid = 0;
2769 char dmsPkgName[PKG_NAME_SIZE_MAX] = { 0 };
2770 (void)TransGetPidAndPkgName(DMS_SESSIONNAME, DMS_UID, &dmsPid, dmsPkgName, PKG_NAME_SIZE_MAX);
2771 if (callingPid != 0 && dmsPid != callingPid) {
2772 TRANS_LOGE(TRANS_CTRL,
2773 "dmsPid does not match callingPid, dmsPid=%{public}d, callingPid=%{public}d", dmsPid, callingPid);
2774 SoftBusHitraceChainEnd();
2775 return SOFTBUS_TRANS_CHECK_PID_ERROR;
2776 }
2777
2778 ProxyChannelInfo chan = { 0 };
2779 int32_t ret = TransProxyGetChanByChanId(channelId, &chan);
2780 if (ret != SOFTBUS_OK) {
2781 TRANS_LOGE(TRANS_CTRL, "get channelInfo failed, channelId=%{public}d.", channelId);
2782 SoftBusHitraceChainEnd();
2783 return ret;
2784 }
2785
2786 ret = TransProxyUpdateReplyCnt(channelId);
2787 if (ret != SOFTBUS_OK) {
2788 TRANS_LOGE(TRANS_CTRL, "update waitOpenReplyCnt failed, channelId=%{public}d.", channelId);
2789 goto ERR_EXIT;
2790 }
2791 // Remove old check tasks.
2792 TransCheckChannelOpenRemoveFromLooper(channelId);
2793 if (checkResult != SOFTBUS_OK) {
2794 TRANS_LOGE(TRANS_CTRL, "check synertistic relation failed, channelId=%{public}d.", channelId);
2795 ret = checkResult;
2796 goto ERR_EXIT;
2797 }
2798 // Reset the check count to 0.
2799 ret = TransProxyResetReplyCnt(channelId);
2800 if (ret != SOFTBUS_OK) {
2801 goto ERR_EXIT;
2802 }
2803
2804 ret = OnProxyChannelOpened(channelId, &(chan.appInfo), PROXY_CHANNEL_SERVER);
2805 if (ret != SOFTBUS_OK) {
2806 goto ERR_EXIT;
2807 }
2808 SoftBusHitraceChainEnd();
2809 return SOFTBUS_OK;
2810
2811 ERR_EXIT:
2812 (void)TransProxyAckHandshake(chan.connId, &chan, ret);
2813 TransProxyDelChanByChanId(channelId);
2814 SoftBusHitraceChainEnd();
2815 return ret;
2816 }
2817