1 /*
2  * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "trans_channel_manager.h"
17 
18 #include <securec.h>
19 
20 #include "access_control.h"
21 #include "anonymizer.h"
22 #include "bus_center_manager.h"
23 #include "lnn_distributed_net_ledger.h"
24 #include "lnn_lane_qos.h"
25 #include "lnn_network_manager.h"
26 #include "session.h"
27 #include "softbus_adapter_mem.h"
28 #include "softbus_conn_interface.h"
29 #include "softbus_def.h"
30 #include "softbus_errcode.h"
31 #include "softbus_feature_config.h"
32 #include "softbus_hisysevt_transreporter.h"
33 #include "softbus_proxychannel_manager.h"
34 #include "softbus_proxychannel_session.h"
35 #include "softbus_proxychannel_transceiver.h"
36 #include "softbus_qos.h"
37 #include "softbus_utils.h"
38 #include "trans_auth_manager.h"
39 #include "trans_auth_negotiation.h"
40 #include "trans_channel_callback.h"
41 #include "trans_channel_common.h"
42 #include "trans_event.h"
43 #include "trans_lane_manager.h"
44 #include "trans_lane_pending_ctl.h"
45 #include "trans_link_listener.h"
46 #include "trans_log.h"
47 #include "trans_network_statistics.h"
48 #include "trans_session_manager.h"
49 #include "trans_tcp_direct_manager.h"
50 #include "trans_tcp_direct_sessionconn.h"
51 #include "trans_udp_channel_manager.h"
52 #include "trans_udp_negotiation.h"
53 
54 #define MIGRATE_ENABLE 2
55 #define MIGRATE_SUPPORTED 1
56 #define MAX_PROXY_CHANNEL_ID 0x00000800
57 #define MAX_TDC_CHANNEL_ID 0x7FFFFFFF
58 #define MIN_FD_ID 1025
59 #define MAX_FD_ID 2048
60 #define MAX_PROXY_CHANNEL_ID_COUNT 1024
61 #define ID_NOT_USED 0
62 #define ID_USED 1UL
63 #define BIT_NUM 8
64 
65 static int32_t g_allocTdcChannelId = MAX_PROXY_CHANNEL_ID;
66 static SoftBusMutex g_myIdLock;
67 static unsigned long g_proxyChanIdBits[MAX_PROXY_CHANNEL_ID_COUNT / BIT_NUM / sizeof(long)] = {0};
68 static uint32_t g_proxyIdMark = 0;
69 static uint32_t g_channelIdCount = 0;
70 
GenerateTdcChannelId()71 static int32_t GenerateTdcChannelId()
72 {
73     int32_t channelId;
74     if (SoftBusMutexLock(&g_myIdLock) != SOFTBUS_OK) {
75         TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
76         return SOFTBUS_LOCK_ERR;
77     }
78     channelId = g_allocTdcChannelId++;
79     if (g_allocTdcChannelId >= MAX_TDC_CHANNEL_ID) {
80         g_allocTdcChannelId = MAX_PROXY_CHANNEL_ID;
81     }
82     SoftBusMutexUnlock(&g_myIdLock);
83     return channelId;
84 }
85 
GenerateProxyChannelId()86 static int32_t GenerateProxyChannelId()
87 {
88     if (SoftBusMutexLock(&g_myIdLock) != SOFTBUS_OK) {
89         TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
90         return SOFTBUS_LOCK_ERR;
91     }
92 
93     if (g_channelIdCount >= MAX_PROXY_CHANNEL_ID_COUNT) {
94         TRANS_LOGE(TRANS_CTRL, "No more channel Ids(1024) can be applied");
95         SoftBusMutexUnlock(&g_myIdLock);
96         return INVALID_CHANNEL_ID;
97     }
98 
99     for (uint32_t id = g_proxyIdMark + 1; id != g_proxyIdMark; id++) {
100         id = id % MAX_PROXY_CHANNEL_ID_COUNT;
101         uint32_t index = id / (BIT_NUM * sizeof(long));
102         uint32_t bit = id % (BIT_NUM * sizeof(long));
103         if ((g_proxyChanIdBits[index] & (ID_USED << bit)) == ID_NOT_USED) {
104             g_proxyChanIdBits[index] |= (ID_USED << bit);
105             g_proxyIdMark = id;
106             g_channelIdCount++;
107             SoftBusMutexUnlock(&g_myIdLock);
108             return (int32_t)id + MIN_FD_ID;
109         }
110     }
111     SoftBusMutexUnlock(&g_myIdLock);
112     return INVALID_CHANNEL_ID;
113 }
114 
ReleaseProxyChannelId(int32_t channelId)115 void ReleaseProxyChannelId(int32_t channelId)
116 {
117     if (channelId < MIN_FD_ID || channelId > MAX_FD_ID) {
118         return;
119     }
120     if (SoftBusMutexLock(&g_myIdLock) != SOFTBUS_OK) {
121         TRANS_LOGE(TRANS_CTRL, "lock mutex fail");
122         return;
123     }
124     if (g_channelIdCount >= ID_USED) {
125         g_channelIdCount--;
126     } else {
127         TRANS_LOGE(TRANS_CTRL, "g_channelIdCount error");
128     }
129     uint32_t id = (uint32_t)channelId - MIN_FD_ID;
130     uint32_t dex = id / (8 * sizeof(long));
131     uint32_t bit = id % (8 * sizeof(long));
132     g_proxyChanIdBits[dex] &= (~(ID_USED << bit));
133     SoftBusMutexUnlock(&g_myIdLock);
134 }
135 
GenerateChannelId(bool isTdcChannel)136 int32_t GenerateChannelId(bool isTdcChannel)
137 {
138     return isTdcChannel ? GenerateTdcChannelId() : GenerateProxyChannelId();
139 }
140 
TransChannelInit(void)141 int32_t TransChannelInit(void)
142 {
143     IServerChannelCallBack *cb = TransServerGetChannelCb();
144     TRANS_CHECK_AND_RETURN_RET_LOGE(cb != NULL, SOFTBUS_NO_INIT, TRANS_INIT, "cd is null.");
145 
146     int32_t ret = TransLaneMgrInit();
147     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "trans lane manager init failed.");
148 
149     ret = TransSocketLaneMgrInit();
150     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "trans socket lane manager init failed.");
151 
152     ret = TransAuthInit(cb);
153     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "trans auth init failed.");
154 
155     ret = TransProxyManagerInit(cb);
156     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "trans proxy manager init failed.");
157 
158     ret = TransTcpDirectInit(cb);
159     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "trans tcp direct init failed.");
160 
161     ret = TransUdpChannelInit(cb);
162     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "trans udp channel init failed.");
163 
164     ret = TransReqLanePendingInit();
165     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "trans req lane pending init failed.");
166 
167     ret = TransNetworkStatisticsInit();
168     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "trans network statistics init failed.");
169 
170     ret = TransAsyncReqLanePendingInit();
171     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "trans async req lane pending init failed.");
172 
173     ret = TransReqAuthPendingInit();
174     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "trans auth request pending init failed.");
175     ret = TransAuthWithParaReqLanePendingInit();
176     TRANS_CHECK_AND_RETURN_RET_LOGE(
177         ret == SOFTBUS_OK, ret, TRANS_INIT, "trans auth with para req lane pending init failed.");
178 
179     ret = TransFreeLanePendingInit();
180     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "trans free lane pending init failed.");
181 
182     ReqLinkListener();
183     ret = SoftBusMutexInit(&g_myIdLock, NULL);
184     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "init lock failed.");
185     return SOFTBUS_OK;
186 }
187 
TransChannelDeinit(void)188 void TransChannelDeinit(void)
189 {
190     TransLaneMgrDeinit();
191     TransSocketLaneMgrDeinit();
192     TransAuthDeinit();
193     TransProxyManagerDeinit();
194     TransTcpDirectDeinit();
195     TransUdpChannelDeinit();
196     TransReqLanePendingDeinit();
197     TransAsyncReqLanePendingDeinit();
198     TransNetworkStatisticsDeinit();
199     TransReqAuthPendingDeinit();
200     TransAuthWithParaReqLanePendingDeinit();
201     TransFreeLanePendingDeinit();
202     SoftBusMutexDestroy(&g_myIdLock);
203 }
204 
TransSetFirstTokenInfo(AppInfo * appInfo,TransEventExtra * event)205 static void TransSetFirstTokenInfo(AppInfo *appInfo, TransEventExtra *event)
206 {
207     event->firstTokenId = TransACLGetFirstTokenID();
208     if (event->firstTokenId == TOKENID_NOT_SET) {
209         event->firstTokenId = appInfo->callingTokenId;
210     }
211     TransGetTokenInfo(event->firstTokenId, appInfo->tokenName, sizeof(appInfo->tokenName), &event->firstTokenType);
212     event->firstTokenName = appInfo->tokenName;
213 }
214 
IsLaneModuleError(int32_t errcode)215 static bool IsLaneModuleError(int32_t errcode)
216 {
217     if (errcode >= SOFTBUS_LANE_ERR_BASE && errcode < SOFTBUS_CONN_ERR_BASE) {
218         return true;
219     }
220     return false;
221 }
222 
TransFreeLaneInner(uint32_t laneHandle,bool isQosLane,bool isAsync)223 static void TransFreeLaneInner(uint32_t laneHandle, bool isQosLane, bool isAsync)
224 {
225     if (isQosLane) {
226         TransFreeLaneByLaneHandle(laneHandle, isAsync);
227     } else {
228         LnnFreeLane(laneHandle);
229     }
230 }
231 
TransOpenChannel(const SessionParam * param,TransInfo * transInfo)232 int32_t TransOpenChannel(const SessionParam *param, TransInfo *transInfo)
233 {
234     if (param == NULL || transInfo == NULL) {
235         TRANS_LOGE(TRANS_CTRL, "param invalid");
236         return SOFTBUS_INVALID_PARAM;
237     }
238     char *tmpName = NULL;
239     Anonymize(param->sessionName, &tmpName);
240     TRANS_LOGI(TRANS_CTRL, "server TransOpenChannel, sessionName=%{public}s, socket=%{public}d, actionId=%{public}d, "
241                            "isQosLane=%{public}d, isAsync=%{public}d",
242         tmpName, param->sessionId, param->actionId, param->isQosLane, param->isAsync);
243     AnonymizeFree(tmpName);
244     int32_t ret = INVALID_CHANNEL_ID;
245     uint32_t laneHandle = INVALID_LANE_REQ_ID;
246     CoreSessionState state = CORE_SESSION_STATE_INIT;
247     AppInfo *appInfo = (AppInfo *)SoftBusCalloc(sizeof(AppInfo));
248     TRANS_CHECK_AND_RETURN_RET_LOGE(appInfo != NULL, SOFTBUS_MALLOC_ERR, TRANS_CTRL, "calloc appInfo failed.");
249     ret = TransCommonGetAppInfo(param, appInfo);
250     if (ret != SOFTBUS_OK) {
251         TRANS_LOGE(TRANS_CTRL, "get appinfo failed");
252         TransFreeAppInfo(appInfo);
253         return ret;
254     }
255     ret = TransAddSocketChannelInfo(
256         param->sessionName, param->sessionId, INVALID_CHANNEL_ID, CHANNEL_TYPE_UNDEFINED, CORE_SESSION_STATE_INIT);
257     if (ret != SOFTBUS_OK) {
258         TRANS_LOGE(TRANS_CTRL, "Add socket channel record failed.");
259         TransFreeAppInfo(appInfo);
260         return ret;
261     }
262     NodeInfo nodeInfo;
263     (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
264     int32_t peerRet = LnnGetRemoteNodeInfoById(appInfo->peerNetWorkId, CATEGORY_NETWORK_ID, &nodeInfo);
265     appInfo->osType = nodeInfo.deviceInfo.osType;
266     TransEventExtra extra;
267     (void)memset_s(&extra, sizeof(TransEventExtra), 0, sizeof(TransEventExtra));
268     TransBuildTransOpenChannelStartEvent(&extra, appInfo, &nodeInfo, peerRet);
269     TransSetFirstTokenInfo(appInfo, &extra);
270     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_OPEN_CHANNEL_START, extra);
271     if (param->isQosLane) {
272         uint32_t callingTokenId = TransACLGetCallingTokenID();
273         ret = TransAsyncGetLaneInfo(param, &laneHandle, callingTokenId, appInfo->timeStart);
274         if (ret != SOFTBUS_OK) {
275             Anonymize(param->sessionName, &tmpName);
276             TRANS_LOGE(TRANS_CTRL, "Async get Lane failed, sessionName=%{public}s, sessionId=%{public}d",
277                 tmpName, param->sessionId);
278             AnonymizeFree(tmpName);
279             if (ret != SOFTBUS_TRANS_STOP_BIND_BY_CANCEL) {
280                 TransFreeLaneInner(laneHandle, param->isQosLane, param->isAsync);
281             }
282             (void)TransDeleteSocketChannelInfoBySession(param->sessionName, param->sessionId);
283         }
284         TransFreeAppInfo(appInfo);
285         return ret;
286     }
287     transInfo->channelId = INVALID_CHANNEL_ID;
288     transInfo->channelType = CHANNEL_TYPE_BUTT;
289     LaneConnInfo connInfo;
290     ConnectOption connOpt;
291     (void)memset_s(&connOpt, sizeof(ConnectOption), 0, sizeof(ConnectOption));
292     ret = TransGetLaneInfo(param, &connInfo, &laneHandle);
293     if (ret != SOFTBUS_OK) {
294         SoftbusReportTransErrorEvt(SOFTBUS_TRANS_GET_LANE_INFO_ERR);
295         goto EXIT_ERR;
296     }
297     Anonymize(param->sessionName, &tmpName);
298     TRANS_LOGI(TRANS_CTRL,
299         "sessionName=%{public}s, socket=%{public}d, laneHandle=%{public}u, linkType=%{public}u.",
300         tmpName, param->sessionId, laneHandle, connInfo.type);
301     AnonymizeFree(tmpName);
302     ret = TransGetConnectOptByConnInfo(&connInfo, &connOpt);
303     if (ret != SOFTBUS_OK) {
304         SoftbusRecordOpenSessionKpi(appInfo->myData.pkgName, connInfo.type,
305             SOFTBUS_EVT_OPEN_SESSION_FAIL, GetSoftbusRecordTimeMillis() - appInfo->timeStart);
306         goto EXIT_ERR;
307     }
308     appInfo->connectType = connOpt.type;
309     extra.linkType = connOpt.type;
310     extra.deviceState = TransGetDeviceState(param->peerDeviceId);
311     FillAppInfo(appInfo, param, transInfo, &connInfo);
312     TransOpenChannelSetModule(transInfo->channelType, &connOpt);
313     TRANS_LOGI(TRANS_CTRL, "laneHandle=%{public}u, channelType=%{public}u", laneHandle, transInfo->channelType);
314     TransGetSocketChannelStateBySession(param->sessionName, param->sessionId, &state);
315     if (state == CORE_SESSION_STATE_CANCELLING) {
316         goto EXIT_CANCEL;
317     }
318     TransSetSocketChannelStateBySession(param->sessionName, param->sessionId, CORE_SESSION_STATE_LAN_COMPLETE);
319     ret = TransOpenChannelProc((ChannelType)transInfo->channelType, appInfo, &connOpt,
320         &(transInfo->channelId));
321     (void)memset_s(appInfo->sessionKey, sizeof(appInfo->sessionKey), 0, sizeof(appInfo->sessionKey));
322     if (ret != SOFTBUS_OK) {
323         SoftbusReportTransErrorEvt(SOFTBUS_TRANS_CREATE_CHANNEL_ERR);
324         SoftbusRecordOpenSessionKpi(appInfo->myData.pkgName,
325             appInfo->linkType, SOFTBUS_EVT_OPEN_SESSION_FAIL, GetSoftbusRecordTimeMillis() - appInfo->timeStart);
326         goto EXIT_ERR;
327     }
328     TransUpdateSocketChannelInfoBySession(
329         param->sessionName, param->sessionId, transInfo->channelId, transInfo->channelType);
330     TransSetSocketChannelStateByChannel(
331         transInfo->channelId, transInfo->channelType, CORE_SESSION_STATE_CHANNEL_OPENED);
332     if (TransLaneMgrAddLane(transInfo, &connInfo, laneHandle, param->isQosLane, &appInfo->myData) != SOFTBUS_OK) {
333         SoftbusRecordOpenSessionKpi(appInfo->myData.pkgName, appInfo->linkType, SOFTBUS_EVT_OPEN_SESSION_FAIL,
334             GetSoftbusRecordTimeMillis() - appInfo->timeStart);
335         TransCloseChannel(NULL, transInfo->channelId, transInfo->channelType);
336         goto EXIT_ERR;
337     }
338     AddChannelStatisticsInfo(transInfo->channelId, transInfo->channelType);
339     TransFreeAppInfo(appInfo);
340     TRANS_LOGI(TRANS_CTRL,
341         "server TransOpenChannel ok: socket=%{public}d, channelId=%{public}d, channelType=%{public}d, "
342         "laneHandle=%{public}u",
343         param->sessionId, transInfo->channelId, transInfo->channelType, laneHandle);
344     return SOFTBUS_OK;
345 EXIT_ERR:
346     extra.linkType = IsLaneModuleError(ret) ? extra.linkType : CONNECT_HML;
347     TransBuildTransOpenChannelEndEvent(&extra, transInfo, appInfo->timeStart, ret);
348     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_OPEN_CHANNEL_END, extra);
349     TransAlarmExtra extraAlarm;
350     TransBuildTransAlarmEvent(&extraAlarm, appInfo, ret);
351     TRANS_ALARM(OPEN_SESSION_FAIL_ALARM, CONTROL_ALARM_TYPE, extraAlarm);
352     TransFreeAppInfo(appInfo);
353     if (ret != SOFTBUS_TRANS_STOP_BIND_BY_CANCEL || laneHandle != INVALID_LANE_REQ_ID) {
354         TransFreeLaneInner(laneHandle, param->isQosLane, param->isAsync);
355     }
356     (void)TransDeleteSocketChannelInfoBySession(param->sessionName, param->sessionId);
357     TRANS_LOGE(TRANS_SVC, "server TransOpenChannel err, socket=%{public}d, ret=%{public}d", param->sessionId, ret);
358     return ret;
359 EXIT_CANCEL:
360     TransBuildTransOpenChannelCancelEvent(&extra, transInfo, appInfo->timeStart, SOFTBUS_TRANS_STOP_BIND_BY_CANCEL);
361     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_OPEN_CHANNEL_END, extra);
362     TransFreeAppInfo(appInfo);
363     TransFreeLaneInner(laneHandle, param->isQosLane, param->isAsync);
364     (void)TransDeleteSocketChannelInfoBySession(param->sessionName, param->sessionId);
365     TRANS_LOGE(TRANS_SVC, "server open channel cancel, socket=%{public}d", param->sessionId);
366     return SOFTBUS_TRANS_STOP_BIND_BY_CANCEL;
367 }
368 
GetAuthAppInfo(const char * mySessionName)369 static AppInfo *GetAuthAppInfo(const char *mySessionName)
370 {
371     TRANS_LOGD(TRANS_CTRL, "enter.");
372     AppInfo *appInfo = (AppInfo *)SoftBusCalloc(sizeof(AppInfo));
373     if (appInfo == NULL) {
374         return NULL;
375     }
376     appInfo->appType = APP_TYPE_AUTH;
377     appInfo->myData.apiVersion = API_V2;
378     appInfo->autoCloseTime = 0;
379     appInfo->businessType = BUSINESS_TYPE_BYTE;
380     appInfo->channelType = CHANNEL_TYPE_AUTH;
381     appInfo->timeStart = GetSoftbusRecordTimeMillis();
382     appInfo->isClient = true;
383     if (TransGetUidAndPid(mySessionName, &appInfo->myData.uid, &appInfo->myData.pid) != SOFTBUS_OK) {
384         TRANS_LOGE(TRANS_CTRL, "GetAuthAppInfo GetUidAndPid failed");
385         goto EXIT_ERR;
386     }
387     if (LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, appInfo->myData.deviceId,
388         sizeof(appInfo->myData.deviceId)) != SOFTBUS_OK) {
389         TRANS_LOGE(TRANS_CTRL, "GetAuthAppInfo get deviceId failed");
390         goto EXIT_ERR;
391     }
392     if (strcpy_s(appInfo->myData.sessionName, sizeof(appInfo->myData.sessionName), mySessionName) != EOK) {
393         TRANS_LOGE(TRANS_CTRL, "GetAuthAppInfo strcpy_s mySessionName failed");
394         goto EXIT_ERR;
395     }
396     if (strcpy_s(appInfo->peerData.sessionName, sizeof(appInfo->peerData.sessionName), mySessionName) != EOK) {
397         TRANS_LOGE(TRANS_CTRL, "GetAuthAppInfo strcpy_s peerSessionName failed");
398         goto EXIT_ERR;
399     }
400     if (TransGetPkgNameBySessionName(mySessionName, appInfo->myData.pkgName, PKG_NAME_SIZE_MAX) != SOFTBUS_OK) {
401         TRANS_LOGE(TRANS_CTRL, "GetAuthAppInfo get PkgName failed");
402         goto EXIT_ERR;
403     }
404     if (TransCommonGetLocalConfig(appInfo->channelType, appInfo->businessType, &appInfo->myData.dataConfig) !=
405         SOFTBUS_OK) {
406         TRANS_LOGE(TRANS_CTRL, "GetAuthAppInfo get local data config failed");
407         goto EXIT_ERR;
408     }
409 
410     TRANS_LOGD(TRANS_CTRL, "ok");
411     return appInfo;
412 EXIT_ERR:
413     SoftBusFree(appInfo);
414     return NULL;
415 }
416 
TransOpenAuthChannel(const char * sessionName,const ConnectOption * connOpt,const char * reqId)417 int32_t TransOpenAuthChannel(const char *sessionName, const ConnectOption *connOpt,
418     const char *reqId)
419 {
420     int32_t channelId = INVALID_CHANNEL_ID;
421     if (!IsValidString(sessionName, SESSION_NAME_SIZE_MAX) || connOpt == NULL) {
422         return channelId;
423     }
424     char callerPkg[PKG_NAME_SIZE_MAX] = {0};
425     char localUdid[UDID_BUF_LEN] = {0};
426     TransEventExtra extra;
427     (void)memset_s(&extra, sizeof(TransEventExtra), 0, sizeof(TransEventExtra));
428     TransBuildOpenAuthChannelStartEvent(&extra, sessionName, connOpt, localUdid, callerPkg);
429     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_OPEN_CHANNEL_START, extra);
430     if (connOpt->type == CONNECT_TCP) {
431         if (TransOpenAuthMsgChannel(sessionName, connOpt, &channelId, reqId) != SOFTBUS_OK) {
432             goto EXIT_ERR;
433         }
434     } else if (connOpt->type == CONNECT_BR || connOpt->type == CONNECT_BLE) {
435         AppInfo *appInfo = GetAuthAppInfo(sessionName);
436         if (appInfo == NULL) {
437             TRANS_LOGE(TRANS_CTRL, "GetAuthAppInfo failed");
438             goto EXIT_ERR;
439         }
440         appInfo->connectType = connOpt->type;
441         if (strcpy_s(appInfo->reqId, REQ_ID_SIZE_MAX, reqId) != EOK) {
442             TRANS_LOGE(TRANS_CTRL, "strcpy_s reqId failed");
443             SoftBusFree(appInfo);
444             goto EXIT_ERR;
445         }
446         if (TransProxyOpenProxyChannel(appInfo, connOpt, &channelId) != SOFTBUS_OK) {
447             TRANS_LOGE(TRANS_CTRL, "proxy channel err");
448             SoftBusFree(appInfo);
449             goto EXIT_ERR;
450         }
451         SoftBusFree(appInfo);
452     } else {
453         goto EXIT_ERR;
454     }
455     return channelId;
456 EXIT_ERR:
457     extra.result = EVENT_STAGE_RESULT_FAILED;
458     extra.errcode = SOFTBUS_TRANS_AUTH_CHANNEL_NOT_FOUND;
459     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_OPEN_CHANNEL_END, extra);
460     return INVALID_CHANNEL_ID;
461 }
462 
MergeStatsInterval(const uint32_t * data,uint32_t left,uint32_t right)463 static uint32_t MergeStatsInterval(const uint32_t *data, uint32_t left, uint32_t right)
464 {
465     uint32_t result = 0;
466     while (left <= right) {
467         result += data[left];
468         left++;
469     }
470     return result;
471 }
472 
ConvertStreamStats(const StreamSendStats * src,FrameSendStats * dest)473 static void ConvertStreamStats(const StreamSendStats *src, FrameSendStats *dest)
474 {
475     uint32_t *srcCostCnt = (uint32_t *)(src->costTimeStatsCnt);
476     uint32_t *srcBitRate = (uint32_t *)(src->sendBitRateStatsCnt);
477     uint32_t *destCostCnt = dest->costTimeStatsCnt;
478     uint32_t *destBitRate = dest->sendBitRateStatsCnt;
479     destCostCnt[FRAME_COST_TIME_SMALL] = srcCostCnt[FRAME_COST_LT10MS];
480     destCostCnt[FRAME_COST_TIME_MEDIUM] = MergeStatsInterval(srcCostCnt, FRAME_COST_LT30MS, FRAME_COST_LT100MS);
481     destCostCnt[FRAME_COST_TIME_LARGE] = srcCostCnt[FRAME_COST_LT120MS] + srcCostCnt[FRAME_COST_GE120MS];
482     destBitRate[FRAME_BIT_RATE_SMALL] = srcBitRate[FRAME_BIT_RATE_LT3M];
483     destBitRate[FRAME_BIT_RATE_MEDIUM] = MergeStatsInterval(srcBitRate, FRAME_BIT_RATE_LT6M, FRAME_BIT_RATE_LT30M);
484     destBitRate[FRAME_BIT_RATE_LARGE] = srcBitRate[FRAME_BIT_RATE_GE30M];
485 }
486 
TransStreamStats(int32_t channelId,int32_t channelType,const StreamSendStats * data)487 int32_t TransStreamStats(int32_t channelId, int32_t channelType, const StreamSendStats *data)
488 {
489     (void)channelType;
490     if (data == NULL) {
491         TRANS_LOGE(TRANS_STREAM, "streamStats data is null");
492         return SOFTBUS_INVALID_PARAM;
493     }
494     uint32_t laneHandle;
495     int32_t ret = TransGetLaneHandleByChannelId(channelId, &laneHandle);
496     if (ret != SOFTBUS_OK) {
497         TRANS_LOGE(TRANS_STREAM, "get laneHandle fail, streamStatsInfo cannot be processed");
498         return ret;
499     }
500     TRANS_LOGI(TRANS_STREAM, "transStreamStats channelId=%{public}d, laneHandle=0x%{public}x", channelId, laneHandle);
501     // modify with laneId
502     uint64_t laneId = INVALID_LANE_ID;
503     LaneIdStatsInfo info;
504     (void)memset_s(&info, sizeof(info), 0, sizeof(info));
505     info.laneId = laneId;
506     info.statsType = LANE_T_COMMON_VIDEO;
507     FrameSendStats *stats = &info.statsInfo.stream.frameStats;
508     ConvertStreamStats(data, stats);
509     LnnReportLaneIdStatsInfo(&info, 1); /* only report stream stats */
510     return SOFTBUS_OK;
511 }
512 
TransRequestQos(int32_t channelId,int32_t chanType,int32_t appType,int32_t quality)513 int32_t TransRequestQos(int32_t channelId, int32_t chanType, int32_t appType, int32_t quality)
514 {
515     (void)chanType;
516     (void)appType;
517     uint32_t laneHandle;
518     int32_t ret = TransGetLaneHandleByChannelId(channelId, &laneHandle);
519     if (ret != SOFTBUS_OK) {
520         TRANS_LOGE(TRANS_QOS, "get laneHandle fail, transRequestQos cannot be processed");
521         return ret;
522     }
523     // modify with laneId
524     uint64_t laneId = INVALID_LANE_ID;
525     int32_t result = 0;
526     if (quality == QOS_IMPROVE) {
527         TRANS_LOGI(TRANS_QOS, "trans requestQos");
528         ret = LnnRequestQosOptimization(&laneId, 1, &result, 1);
529     } else if (quality == QOS_RECOVER) {
530         TRANS_LOGI(TRANS_QOS, "trans cancel Qos");
531         LnnCancelQosOptimization(&laneId, 1);
532         ret = SOFTBUS_OK;
533     } else {
534         TRANS_LOGE(TRANS_QOS, "requestQos invalid. quality=%{public}d", quality);
535         ret = SOFTBUS_TRANS_REQUEST_QOS_INVALID;
536     }
537 
538     if (ret != SOFTBUS_OK) {
539         TRANS_LOGE(TRANS_QOS, "request Qos fail, quality=%{public}d, ret=%{public}d", quality, ret);
540         return SOFTBUS_TRANS_REQUEST_QOS_FAILED;
541     }
542     return SOFTBUS_OK;
543 }
544 
TransRippleStats(int32_t channelId,int32_t channelType,const TrafficStats * data)545 int32_t TransRippleStats(int32_t channelId, int32_t channelType, const TrafficStats *data)
546 {
547     (void)channelType;
548     if (data == NULL) {
549         TRANS_LOGE(TRANS_CTRL, "rippleStats data is null");
550         return SOFTBUS_INVALID_PARAM;
551     }
552     uint32_t laneHandle;
553     int32_t ret = TransGetLaneHandleByChannelId(channelId, &laneHandle);
554     if (ret != SOFTBUS_OK) {
555         TRANS_LOGE(TRANS_CTRL, "get laneHandle fail, streamStatsInfo cannot be processed, ret=%{public}d", ret);
556         return ret;
557     }
558     TRANS_LOGI(TRANS_CTRL, "transRippleStats channelId=%{public}d, laneHandle=0x%{public}x", channelId, laneHandle);
559     LnnRippleData rptdata;
560     (void)memset_s(&rptdata, sizeof(rptdata), 0, sizeof(rptdata));
561     if (memcpy_s(&rptdata.stats, sizeof(rptdata.stats), data->stats, sizeof(data->stats)) != EOK) {
562         TRANS_LOGE(TRANS_CTRL, "memcpy fail");
563         return SOFTBUS_MEM_ERR;
564     }
565     // modify with laneId
566     uint64_t laneId = INVALID_LANE_ID;
567     LnnReportRippleData(laneId, &rptdata);
568     return SOFTBUS_OK;
569 }
570 
TransNotifyAuthSuccess(int32_t channelId,int32_t channelType)571 int32_t TransNotifyAuthSuccess(int32_t channelId, int32_t channelType)
572 {
573     int32_t ret = SOFTBUS_TRANS_INVALID_CHANNEL_TYPE;
574     ConnectOption connOpt;
575     switch (channelType) {
576         case CHANNEL_TYPE_AUTH:
577             ret = TransAuthGetConnOptionByChanId(channelId, &connOpt);
578             break;
579         case CHANNEL_TYPE_PROXY:
580             ret = TransProxyGetConnOptionByChanId(channelId, &connOpt);
581             break;
582         default:
583             ret = SOFTBUS_TRANS_INVALID_CHANNEL_TYPE;
584             TRANS_LOGE(TRANS_CTRL, "invalid. channelId=%{public}d, channelType=%{public}d.", channelId, channelType);
585     }
586     if (ret != SOFTBUS_OK) {
587         TRANS_LOGE(TRANS_CTRL,
588             "notfiy auth success. channelId=%{public}d, channelType=%{public}d, ret=%{public}d",
589             channelId, channelType, ret);
590         return ret;
591     }
592     return TransNotifyAuthDataSuccess(channelId, &connOpt);
593 }
594 
TransReleaseUdpResources(int32_t channelId)595 int32_t TransReleaseUdpResources(int32_t channelId)
596 {
597     TRANS_LOGI(TRANS_CTRL, "release Udp channel resources: channelId=%{public}d", channelId);
598     NotifyQosChannelClosed(channelId, CHANNEL_TYPE_UDP);
599     (void)TransLaneMgrDelLane(channelId, CHANNEL_TYPE_UDP, false);
600     (void)TransDelUdpChannel(channelId);
601     return SOFTBUS_OK;
602 }
603 
TransCloseChannel(const char * sessionName,int32_t channelId,int32_t channelType)604 int32_t TransCloseChannel(const char *sessionName, int32_t channelId, int32_t channelType)
605 {
606     int32_t ret = TransCommonCloseChannel(sessionName, channelId, channelType);
607     if (IsTdcRecoveryTransLimit() && IsUdpRecoveryTransLimit()) {
608         UdpChannelFileTransRecoveryLimit(FILE_PRIORITY_BE);
609     }
610     return ret;
611 }
612 
TransCloseChannelWithStatistics(int32_t channelId,int32_t channelType,uint64_t laneId,const void * dataInfo,uint32_t len)613 int32_t TransCloseChannelWithStatistics(int32_t channelId, int32_t channelType, uint64_t laneId,
614     const void *dataInfo, uint32_t len)
615 {
616     UpdateNetworkResourceByLaneId(channelId, channelType, laneId, dataInfo, len);
617     return SOFTBUS_OK;
618 }
619 
TransSendMsg(int32_t channelId,int32_t channelType,const void * data,uint32_t len,int32_t msgType)620 int32_t TransSendMsg(int32_t channelId, int32_t channelType, const void *data, uint32_t len,
621     int32_t msgType)
622 {
623     int32_t ret = SOFTBUS_OK;
624     switch (channelType) {
625         case CHANNEL_TYPE_AUTH:
626             TRANS_LOGI(TRANS_MSG,
627                 "send msg auth channelType. channelId=%{public}d, channelType=%{public}d", channelId, channelType);
628             ret = TransSendAuthMsg(channelId, (char*)data, (int32_t)len);
629             break;
630         case CHANNEL_TYPE_PROXY:
631             TRANS_LOGD(TRANS_MSG,
632                 "send msg proxy channelType. channelId=%{public}d, channelType=%{public}d", channelId, channelType);
633             ret = TransProxyPostSessionData(channelId, (unsigned char*)data, len, (SessionPktType)msgType);
634             break;
635         default:
636             TRANS_LOGE(TRANS_MSG,
637                 "send msg invalid channelType. channelId=%{public}d, channelType=%{public}d", channelId, channelType);
638             ret = SOFTBUS_TRANS_CHANNEL_TYPE_INVALID;
639             break;
640     }
641     return ret;
642 }
643 
TransChannelDeathCallback(const char * pkgName,int32_t pid)644 void TransChannelDeathCallback(const char *pkgName, int32_t pid)
645 {
646     TransProxyDeathCallback(pkgName, pid);
647     TransTdcDeathCallback(pkgName, pid);
648     TransTdcChannelInfoDeathCallback(pkgName, pid);
649     TransLaneMgrDeathCallback(pkgName, pid);
650     TransUdpDeathCallback(pkgName, pid);
651 }
652 
TransGetNameByChanId(const TransInfo * info,char * pkgName,char * sessionName,uint16_t pkgLen,uint16_t sessionNameLen)653 int32_t TransGetNameByChanId(const TransInfo *info, char *pkgName, char *sessionName,
654     uint16_t pkgLen, uint16_t sessionNameLen)
655 {
656     if (info == NULL || pkgName == NULL || sessionName == NULL) {
657         TRANS_LOGE(TRANS_CTRL, "invalid param");
658         return SOFTBUS_INVALID_PARAM;
659     }
660     switch ((ChannelType)info->channelType) {
661         case CHANNEL_TYPE_PROXY:
662             return TransProxyGetNameByChanId(info->channelId, pkgName, sessionName, pkgLen, sessionNameLen);
663         case CHANNEL_TYPE_UDP:
664             return TransUdpGetNameByChanId(info->channelId, pkgName, sessionName, pkgLen, sessionNameLen);
665         case CHANNEL_TYPE_AUTH:
666             return TransAuthGetNameByChanId(info->channelId, pkgName, sessionName, pkgLen, sessionNameLen);
667         default:
668             return SOFTBUS_INVALID_PARAM;
669     }
670 }
671 
TransGetAndComparePid(pid_t pid,int32_t channelId,int32_t channelType)672 int32_t TransGetAndComparePid(pid_t pid, int32_t channelId, int32_t channelType)
673 {
674     int32_t curChannelPid;
675     int32_t ret = SOFTBUS_OK;
676     if ((ChannelType)channelType == CHANNEL_TYPE_TCP_DIRECT) {
677         ret = TransGetPidByChanId(channelId, channelType, &curChannelPid);
678         if (ret != SOFTBUS_OK) {
679             TRANS_LOGE(TRANS_CTRL, "get pid by channelId failed, channelId=%{public}d", channelId);
680             return ret;
681         }
682     } else {
683         AppInfo appInfo;
684         ret = TransGetAppInfoByChanId(channelId, channelType, &appInfo);
685         (void)memset_s(appInfo.sessionKey, sizeof(appInfo.sessionKey), 0, sizeof(appInfo.sessionKey));
686         if (ret != SOFTBUS_OK) {
687             TRANS_LOGE(TRANS_CTRL, "get appInfo by channelId failed, channelId=%{public}d", channelId);
688             return ret;
689         }
690         curChannelPid = appInfo.myData.pid;
691     }
692     if (pid != (pid_t)curChannelPid) {
693         TRANS_LOGE(TRANS_CTRL, "callingPid=%{public}d not equal curChannelPid=%{public}d", pid, curChannelPid);
694         return SOFTBUS_TRANS_CHECK_PID_ERROR;
695     }
696     return SOFTBUS_OK;
697 }
698 
TransGetAndComparePidBySession(pid_t pid,const char * sessionName,int32_t sessionlId)699 int32_t TransGetAndComparePidBySession(pid_t pid, const char *sessionName, int32_t sessionlId)
700 {
701     pid_t curSessionPid;
702     int32_t ret = TransGetPidFromSocketChannelInfoBySession(sessionName, sessionlId, &curSessionPid);
703     if (ret != SOFTBUS_OK) {
704         TRANS_LOGE(TRANS_CTRL, "get pid by session failed, ret=%{public}d", ret);
705         return ret;
706     }
707     if (pid != curSessionPid) {
708         TRANS_LOGE(TRANS_CTRL, "callingPid=%{public}d not equal curSessionPid=%{public}d", pid, curSessionPid);
709         return SOFTBUS_TRANS_CHECK_PID_ERROR;
710     }
711     return SOFTBUS_OK;
712 }
713 
TransGetAppInfoByChanId(int32_t channelId,int32_t channelType,AppInfo * appInfo)714 int32_t TransGetAppInfoByChanId(int32_t channelId, int32_t channelType, AppInfo* appInfo)
715 {
716     if (appInfo == NULL) {
717         return SOFTBUS_INVALID_PARAM;
718     }
719     switch ((ChannelType)channelType) {
720         case CHANNEL_TYPE_TCP_DIRECT:
721             return TcpTranGetAppInfobyChannelId(channelId, appInfo);
722         case CHANNEL_TYPE_PROXY:
723             return TransProxyGetAppInfoByChanId(channelId, appInfo);
724         case CHANNEL_TYPE_UDP:
725             return TransGetUdpAppInfoByChannelId(channelId, appInfo);
726         case CHANNEL_TYPE_AUTH:
727             return TransAuthGetAppInfoByChanId(channelId, appInfo);
728         default:
729             return SOFTBUS_INVALID_PARAM;
730     }
731 }
732 
TransGetConnByChanId(int32_t channelId,int32_t channelType,int32_t * connId)733 int32_t TransGetConnByChanId(int32_t channelId, int32_t channelType, int32_t* connId)
734 {
735     int32_t ret;
736 
737     switch (channelType) {
738         case CHANNEL_TYPE_PROXY:
739             ret = TransProxyGetConnIdByChanId(channelId, connId);
740             break;
741         case CHANNEL_TYPE_AUTH:
742             ret = TransAuthGetConnIdByChanId(channelId, connId);
743             break;
744         default:
745             TRANS_LOGE(TRANS_CTRL, "channelType=%{public}d error", channelType);
746             ret = SOFTBUS_TRANS_INVALID_CHANNEL_TYPE;
747     }
748     if (ret != SOFTBUS_OK) {
749         TRANS_LOGE(TRANS_MSG, "get connId failed, channelId=%{public}d, channelType=%{public}d",
750             channelId, channelType);
751     }
752 
753     return ret;
754 }
755 
CheckAuthChannelIsExit(ConnectOption * connInfo)756 int32_t CheckAuthChannelIsExit(ConnectOption *connInfo)
757 {
758     if (connInfo == NULL) {
759         TRANS_LOGE(TRANS_CTRL, "invalid param");
760         return SOFTBUS_INVALID_PARAM;
761     }
762 
763     int32_t ret = SOFTBUS_TRANS_NOT_MATCH;
764     if (connInfo->type == CONNECT_TCP) {
765         ret = CheckIsWifiAuthChannel(connInfo);
766     } else if (connInfo->type == CONNECT_BR || connInfo->type == CONNECT_BLE) {
767         ret = CheckIsProxyAuthChannel(connInfo);
768     }
769     TRANS_LOGW(TRANS_CTRL, "connInfo type=%{public}d, ret=%{public}d", connInfo->type, ret);
770     return ret;
771 }