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_callback.h"
17 #include "bus_center_info_key.h"
18 #include "bus_center_manager.h"
19 #include "lnn_distributed_net_ledger.h"
20 #include "securec.h"
21 #include "softbus_adapter_hitrace.h"
22 #include "softbus_adapter_mem.h"
23 #include "softbus_app_info.h"
24 #include "softbus_def.h"
25 #include "softbus_errcode.h"
26 #include "softbus_hisysevt_transreporter.h"
27 #include "softbus_qos.h"
28 #include "trans_channel_common.h"
29 #include "trans_client_proxy.h"
30 #include "trans_event.h"
31 #include "trans_lane_manager.h"
32 #include "trans_log.h"
33 #include "trans_session_manager.h"
34 #include "trans_tcp_direct_sessionconn.h"
35 #include "trans_udp_channel_manager.h"
36 
37 static IServerChannelCallBack g_channelCallBack;
38 
TransAddTcpChannel(const ChannelInfo * channel,const char * pkgName,int32_t pid)39 static int32_t TransAddTcpChannel(const ChannelInfo *channel, const char *pkgName, int32_t pid)
40 {
41     TcpChannelInfo *info = CreateTcpChannelInfo(channel);
42     if (info == NULL) {
43         TRANS_LOGE(TRANS_CTRL, "create new TcpChannelInfo failed.");
44         return SOFTBUS_MEM_ERR;
45     }
46     info->pid = pid;
47     if (strcpy_s(info->pkgName, sizeof(info->pkgName), pkgName) != EOK) {
48         TRANS_LOGE(TRANS_CTRL, "copy pkgName failed.");
49         SoftBusFree(info);
50         return SOFTBUS_STRCPY_ERR;
51     }
52     int32_t ret = TransAddTcpChannelInfo(info);
53     if (ret != SOFTBUS_OK) {
54         TRANS_LOGE(TRANS_CTRL, "TransAddTcpChannelInfo failed.");
55         SoftBusFree(info);
56     }
57     return ret;
58 }
59 
TransServerOnChannelOpened(const char * pkgName,int32_t pid,const char * sessionName,const ChannelInfo * channel)60 static int32_t TransServerOnChannelOpened(const char *pkgName, int32_t pid, const char *sessionName,
61     const ChannelInfo *channel)
62 {
63     if (pkgName == NULL || sessionName == NULL || channel == NULL) {
64         return SOFTBUS_INVALID_PARAM;
65     }
66     char peerUdid[DEVICE_ID_SIZE_MAX] = { 0 };
67     if (channel->isEncrypt) {
68         GetRemoteUdidWithNetworkId(channel->peerDeviceId, peerUdid, sizeof(peerUdid));
69     }
70     int32_t osType = 0;
71     GetOsTypeByNetworkId(channel->peerDeviceId, &osType);
72     char localUdid[UDID_BUF_LEN] = { 0 };
73     (void)LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, localUdid, sizeof(localUdid));
74     char deviceVersion[DEVICE_VERSION_SIZE_MAX] = { 0 };
75     TransGetRemoteDeviceVersion(channel->peerDeviceId, channel->isEncrypt ? CATEGORY_NETWORK_ID : CATEGORY_UDID,
76         deviceVersion, sizeof(deviceVersion));
77     int64_t timeStart = channel->timeStart;
78     int64_t timediff = GetSoftbusRecordTimeMillis() - timeStart;
79     TransEventExtra extra = {
80         .calleePkg = NULL,
81         .peerNetworkId = channel->peerDeviceId,
82         .linkType = channel->connectType,
83         .channelId = channel->channelId,
84         .costTime = (int32_t)timediff,
85         .result = EVENT_STAGE_RESULT_OK,
86         .callerPkg = pkgName,
87         .socketName = sessionName,
88         .osType = (osType < 0) ? UNKNOW_OS_TYPE : osType,
89         .peerDevVer = deviceVersion,
90         .localUdid = localUdid,
91         .peerUdid = channel->isEncrypt ? peerUdid : channel->peerDeviceId
92     };
93     extra.deviceState = TransGetDeviceState(channel->peerDeviceId);
94     if (!channel->isServer) {
95         CoreSessionState state = CORE_SESSION_STATE_INIT;
96         TransGetSocketChannelStateByChannel(channel->channelId, channel->channelType, &state);
97         if (state == CORE_SESSION_STATE_CANCELLING) {
98             char *tmpName = NULL;
99             Anonymize(sessionName, &tmpName);
100             TRANS_LOGW(TRANS_CTRL, "Cancel bind name=%{public}s, channelId=%{public}d", tmpName, channel->channelId);
101             AnonymizeFree(tmpName);
102             extra.result = EVENT_STAGE_RESULT_CANCELED;
103             TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL_SERVER, EVENT_STAGE_OPEN_CHANNEL_END, extra);
104             return SOFTBUS_TRANS_STOP_BIND_BY_CANCEL;
105         }
106         TransSetSocketChannelStateByChannel(
107             channel->channelId, channel->channelType, CORE_SESSION_STATE_CHANNEL_OPENED);
108     }
109     int32_t ret = !channel->isServer && channel->channelType == CHANNEL_TYPE_UDP && NotifyQosChannelOpened(channel);
110     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "NotifyQosChannelOpened failed.");
111     int32_t sceneCommand = channel->isServer ? EVENT_SCENE_OPEN_CHANNEL_SERVER : EVENT_SCENE_OPEN_CHANNEL;
112     TRANS_EVENT(sceneCommand, EVENT_STAGE_OPEN_CHANNEL_END, extra);
113     SoftbusRecordOpenSessionKpi(pkgName, channel->linkType, SOFTBUS_EVT_OPEN_SESSION_SUCC, timediff);
114     SoftbusHitraceStop();
115     if (channel->channelType == CHANNEL_TYPE_TCP_DIRECT) {
116         (void)TransAddTcpChannel(channel, pkgName, pid);
117     }
118     ret = ClientIpcOnChannelOpened(pkgName, sessionName, channel, pid);
119     if (channel->channelType == CHANNEL_TYPE_TCP_DIRECT && ret != SOFTBUS_OK) {
120         (void)TransDelTcpChannelInfoByChannelId(channel->channelId);
121     }
122     if (!IsTdcRecoveryTransLimit() || !IsUdpRecoveryTransLimit()) {
123         (void)UdpChannelFileTransLimit(channel, FILE_PRIORITY_BK);
124     }
125     return ret;
126 }
127 
TransServerOnChannelClosed(const char * pkgName,int32_t pid,int32_t channelId,int32_t channelType,int32_t messageType)128 static int32_t TransServerOnChannelClosed(
129     const char *pkgName, int32_t pid, int32_t channelId, int32_t channelType, int32_t messageType)
130 {
131     if (pkgName == NULL) {
132         return SOFTBUS_INVALID_PARAM;
133     }
134 
135     (void)TransLaneMgrDelLane(channelId, channelType, true);
136     NotifyQosChannelClosed(channelId, channelType);
137     ChannelMsg data = {
138         .msgChannelId = channelId,
139         .msgChannelType = channelType,
140         .msgPid = pid,
141         .msgMessageType = messageType,
142         .msgPkgName = pkgName,
143         .msgUuid = NULL,
144         .msgUdid = NULL
145     };
146     TransDeleteSocketChannelInfoByChannel(channelId, channelType);
147     if (ClientIpcOnChannelClosed(&data) != SOFTBUS_OK) {
148         TRANS_LOGE(TRANS_CTRL, "client ipc on channel close fail");
149         return SOFTBUS_IPC_ERR;
150     }
151     if (IsTdcRecoveryTransLimit() && IsUdpRecoveryTransLimit()) {
152         UdpChannelFileTransRecoveryLimit(FILE_PRIORITY_BE);
153     }
154     return SOFTBUS_OK;
155 }
156 
TransServerOnChannelOpenFailed(const char * pkgName,int32_t pid,int32_t channelId,int32_t channelType,int32_t errCode)157 static int32_t TransServerOnChannelOpenFailed(const char *pkgName, int32_t pid, int32_t channelId,
158     int32_t channelType, int32_t errCode)
159 {
160     if (pkgName == NULL) {
161         return SOFTBUS_INVALID_PARAM;
162     }
163     if (TransLaneMgrDelLane(channelId, channelType, true) != SOFTBUS_OK) {
164         TRANS_LOGW(TRANS_CTRL, "delete lane object failed.");
165     }
166     NotifyQosChannelClosed(channelId, channelType);
167     ChannelMsg data = {
168         .msgChannelId = channelId,
169         .msgChannelType = channelType,
170         .msgPid = pid,
171         .msgPkgName = pkgName,
172         .msgUuid = NULL,
173         .msgUdid = NULL
174     };
175     TransDeleteSocketChannelInfoByChannel(channelId, channelType);
176     if (ClientIpcOnChannelOpenFailed(&data, errCode) != SOFTBUS_OK) {
177         TRANS_LOGE(TRANS_CTRL, "client ipc on channel open fail");
178         return SOFTBUS_IPC_ERR;
179     }
180     SoftbusHitraceStop();
181     TRANS_LOGW(TRANS_CTRL,
182         "trasn server on channel open failed. pkgname=%{public}s, channelId=%{public}d, type=%{public}d",
183         pkgName, channelId, channelType);
184     return SOFTBUS_OK;
185 }
186 
TransServerOnMsgReceived(const char * pkgName,int32_t pid,int32_t channelId,int32_t channelType,TransReceiveData * receiveData)187 static int32_t TransServerOnMsgReceived(const char *pkgName, int32_t pid, int32_t channelId, int32_t channelType,
188     TransReceiveData* receiveData)
189 {
190     if (pkgName == NULL || receiveData == NULL || receiveData->data == NULL || receiveData->dataLen == 0) {
191         return SOFTBUS_INVALID_PARAM;
192     }
193 
194     ChannelMsg data = {
195         .msgChannelId = channelId,
196         .msgChannelType = channelType,
197         .msgPid = pid,
198         .msgPkgName = pkgName,
199         .msgUuid = NULL,
200         .msgUdid = NULL
201     };
202     if (ClientIpcOnChannelMsgReceived(&data, receiveData) != SOFTBUS_OK) {
203         TRANS_LOGE(TRANS_CTRL, "get pkg name fail");
204         return SOFTBUS_IPC_ERR;
205     }
206     return SOFTBUS_OK;
207 }
208 
TransServerOnQosEvent(const char * pkgName,const QosParam * param)209 static int32_t TransServerOnQosEvent(const char *pkgName, const QosParam *param)
210 {
211     if (pkgName == NULL || param == NULL || param->tvCount <= 0) {
212         return SOFTBUS_INVALID_PARAM;
213     }
214 
215     if (ClientIpcOnChannelQosEvent(pkgName, param) != SOFTBUS_OK) {
216         TRANS_LOGE(TRANS_CTRL, "ClientIpcOnChannelQosEvent fail");
217         return SOFTBUS_IPC_ERR;
218     }
219     return SOFTBUS_OK;
220 }
221 
TransServerOnChannelBind(const char * pkgName,int32_t pid,int32_t channelId,int32_t channelType)222 static int32_t TransServerOnChannelBind(const char *pkgName, int32_t pid, int32_t channelId, int32_t channelType)
223 {
224     if (pkgName == NULL) {
225         TRANS_LOGE(TRANS_CTRL, "pkgName is null channelId=%{public}d", channelId);
226         return SOFTBUS_INVALID_PARAM;
227     }
228     ChannelMsg data = {
229         .msgChannelId = channelId,
230         .msgChannelType = channelType,
231         .msgPid = pid,
232         .msgPkgName = pkgName,
233         .msgUuid = NULL,
234         .msgUdid = NULL
235     };
236     int32_t ret = ClientIpcOnChannelBind(&data);
237     if (ret != SOFTBUS_OK) {
238         TRANS_LOGE(TRANS_CTRL, "client ipc on channel bind fail, ret=%{public}d, channelId=%{public}d", ret, channelId);
239         return ret;
240     }
241     char *anonymizePkgName = NULL;
242     Anonymize(pkgName, &anonymizePkgName);
243     TRANS_LOGI(TRANS_CTRL,
244         "trasn server on channel bind. pkgname=%{public}s, channelId=%{public}d, type=%{public}d",
245         anonymizePkgName, channelId, channelType);
246     AnonymizeFree(anonymizePkgName);
247     return SOFTBUS_OK;
248 }
249 
TransServerGetChannelCb(void)250 IServerChannelCallBack *TransServerGetChannelCb(void)
251 {
252     g_channelCallBack.OnChannelOpened = TransServerOnChannelOpened;
253     g_channelCallBack.OnChannelClosed = TransServerOnChannelClosed;
254     g_channelCallBack.OnChannelOpenFailed = TransServerOnChannelOpenFailed;
255     g_channelCallBack.OnDataReceived = TransServerOnMsgReceived;
256     g_channelCallBack.OnQosEvent = TransServerOnQosEvent;
257     g_channelCallBack.GetPkgNameBySessionName = TransGetPkgNameBySessionName;
258     g_channelCallBack.GetUidAndPidBySessionName = TransGetUidAndPid;
259     g_channelCallBack.OnChannelBind = TransServerOnChannelBind;
260     return &g_channelCallBack;
261 }
262 
TransServerOnChannelLinkDown(const char * pkgName,int32_t pid,const LinkDownInfo * info)263 int32_t TransServerOnChannelLinkDown(const char *pkgName, int32_t pid, const LinkDownInfo *info)
264 {
265     if (pkgName == NULL || info == NULL || info->networkId == NULL) {
266         return SOFTBUS_INVALID_PARAM;
267     }
268     TRANS_LOGD(TRANS_CTRL, "pkgName=%{public}s", pkgName);
269 
270     ChannelMsg data = {
271         .msgPid = pid,
272         .msgPkgName = pkgName,
273         .msgUuid = info->uuid,
274         .msgUdid = info->udid
275     };
276     if (ClientIpcOnChannelLinkDown(&data, info->networkId, info->peerIp, info->routeType) != SOFTBUS_OK) {
277         TRANS_LOGE(TRANS_CTRL, "client ipc on channel link down fail");
278         return SOFTBUS_IPC_ERR;
279     }
280     return SOFTBUS_OK;
281 }
282 
283