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 "legacy/softbus_adapter_hitrace.h"
22 #include "softbus_adapter_mem.h"
23 #include "softbus_app_info.h"
24 #include "softbus_def.h"
25 #include "softbus_error_code.h"
26 #include "legacy/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",
101 AnonymizeWrapper(tmpName), channel->channelId);
102 AnonymizeFree(tmpName);
103 extra.result = EVENT_STAGE_RESULT_CANCELED;
104 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_OPEN_CHANNEL_END, extra);
105 return SOFTBUS_TRANS_STOP_BIND_BY_CANCEL;
106 }
107 TransSetSocketChannelStateByChannel(
108 channel->channelId, channel->channelType, CORE_SESSION_STATE_CHANNEL_OPENED);
109 }
110 int32_t ret = !channel->isServer && channel->channelType == CHANNEL_TYPE_UDP && NotifyQosChannelOpened(channel);
111 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "NotifyQosChannelOpened failed.");
112 int32_t sceneCommand = channel->isServer ? EVENT_SCENE_OPEN_CHANNEL_SERVER : EVENT_SCENE_OPEN_CHANNEL;
113 TRANS_EVENT(sceneCommand, EVENT_STAGE_OPEN_CHANNEL_END, extra);
114
115 SoftbusRecordOpenSessionKpi(pkgName, channel->linkType, SOFTBUS_EVT_OPEN_SESSION_SUCC, timediff);
116 SoftbusHitraceStop();
117 if (channel->channelType == CHANNEL_TYPE_TCP_DIRECT) {
118 (void)TransAddTcpChannel(channel, pkgName, pid);
119 }
120 ret = ClientIpcOnChannelOpened(pkgName, sessionName, channel, pid);
121 if (channel->channelType == CHANNEL_TYPE_TCP_DIRECT && ret != SOFTBUS_OK) {
122 (void)TransDelTcpChannelInfoByChannelId(channel->channelId);
123 }
124 if (!IsTdcRecoveryTransLimit() || !IsUdpRecoveryTransLimit()) {
125 (void)UdpChannelFileTransLimit(channel, FILE_PRIORITY_BK);
126 }
127 return ret;
128 }
129
TransServerOnChannelClosed(const char * pkgName,int32_t pid,int32_t channelId,int32_t channelType,int32_t messageType)130 static int32_t TransServerOnChannelClosed(
131 const char *pkgName, int32_t pid, int32_t channelId, int32_t channelType, int32_t messageType)
132 {
133 if (pkgName == NULL) {
134 return SOFTBUS_INVALID_PARAM;
135 }
136
137 (void)TransLaneMgrDelLane(channelId, channelType, true);
138 NotifyQosChannelClosed(channelId, channelType);
139 ChannelMsg data = {
140 .msgChannelId = channelId,
141 .msgChannelType = channelType,
142 .msgPid = pid,
143 .msgMessageType = messageType,
144 .msgPkgName = pkgName,
145 .msgUuid = NULL,
146 .msgUdid = NULL
147 };
148 TransDeleteSocketChannelInfoByChannel(channelId, channelType);
149 if (ClientIpcOnChannelClosed(&data) != SOFTBUS_OK) {
150 TRANS_LOGE(TRANS_CTRL, "client ipc on channel close fail");
151 return SOFTBUS_IPC_ERR;
152 }
153 if (IsTdcRecoveryTransLimit() && IsUdpRecoveryTransLimit()) {
154 UdpChannelFileTransRecoveryLimit(FILE_PRIORITY_BE);
155 }
156 return SOFTBUS_OK;
157 }
158
TransServerOnChannelOpenFailed(const char * pkgName,int32_t pid,int32_t channelId,int32_t channelType,int32_t errCode)159 static int32_t TransServerOnChannelOpenFailed(const char *pkgName, int32_t pid, int32_t channelId,
160 int32_t channelType, int32_t errCode)
161 {
162 if (pkgName == NULL) {
163 return SOFTBUS_INVALID_PARAM;
164 }
165 if (TransLaneMgrDelLane(channelId, channelType, true) != SOFTBUS_OK) {
166 TRANS_LOGW(TRANS_CTRL, "delete lane object failed.");
167 }
168 NotifyQosChannelClosed(channelId, channelType);
169 ChannelMsg data = {
170 .msgChannelId = channelId,
171 .msgChannelType = channelType,
172 .msgPid = pid,
173 .msgPkgName = pkgName,
174 .msgUuid = NULL,
175 .msgUdid = NULL
176 };
177 TransDeleteSocketChannelInfoByChannel(channelId, channelType);
178 if (ClientIpcOnChannelOpenFailed(&data, errCode) != SOFTBUS_OK) {
179 TRANS_LOGE(TRANS_CTRL, "client ipc on channel open fail");
180 return SOFTBUS_IPC_ERR;
181 }
182 SoftbusHitraceStop();
183 TRANS_LOGW(TRANS_CTRL,
184 "trasn server on channel open failed. pkgname=%{public}s, channelId=%{public}d, type=%{public}d",
185 pkgName, channelId, channelType);
186 return SOFTBUS_OK;
187 }
188
TransServerOnMsgReceived(const char * pkgName,int32_t pid,int32_t channelId,int32_t channelType,TransReceiveData * receiveData)189 static int32_t TransServerOnMsgReceived(const char *pkgName, int32_t pid, int32_t channelId, int32_t channelType,
190 TransReceiveData* receiveData)
191 {
192 if (pkgName == NULL || receiveData == NULL || receiveData->data == NULL || receiveData->dataLen == 0) {
193 return SOFTBUS_INVALID_PARAM;
194 }
195
196 ChannelMsg data = {
197 .msgChannelId = channelId,
198 .msgChannelType = channelType,
199 .msgPid = pid,
200 .msgPkgName = pkgName,
201 .msgUuid = NULL,
202 .msgUdid = NULL
203 };
204 if (ClientIpcOnChannelMsgReceived(&data, receiveData) != SOFTBUS_OK) {
205 TRANS_LOGE(TRANS_CTRL, "get pkg name fail");
206 return SOFTBUS_IPC_ERR;
207 }
208 return SOFTBUS_OK;
209 }
210
TransServerOnQosEvent(const char * pkgName,const QosParam * param)211 static int32_t TransServerOnQosEvent(const char *pkgName, const QosParam *param)
212 {
213 if (pkgName == NULL || param == NULL || param->tvCount <= 0) {
214 return SOFTBUS_INVALID_PARAM;
215 }
216
217 if (ClientIpcOnChannelQosEvent(pkgName, param) != SOFTBUS_OK) {
218 TRANS_LOGE(TRANS_CTRL, "ClientIpcOnChannelQosEvent fail");
219 return SOFTBUS_IPC_ERR;
220 }
221 return SOFTBUS_OK;
222 }
223
TransServerOnChannelBind(const char * pkgName,int32_t pid,int32_t channelId,int32_t channelType)224 static int32_t TransServerOnChannelBind(const char *pkgName, int32_t pid, int32_t channelId, int32_t channelType)
225 {
226 if (pkgName == NULL) {
227 TRANS_LOGE(TRANS_CTRL, "pkgName is null channelId=%{public}d", channelId);
228 return SOFTBUS_INVALID_PARAM;
229 }
230 ChannelMsg data = {
231 .msgChannelId = channelId,
232 .msgChannelType = channelType,
233 .msgPid = pid,
234 .msgPkgName = pkgName,
235 .msgUuid = NULL,
236 .msgUdid = NULL
237 };
238 int32_t ret = ClientIpcOnChannelBind(&data);
239 if (ret != SOFTBUS_OK) {
240 TRANS_LOGE(TRANS_CTRL, "client ipc on channel bind fail, ret=%{public}d, channelId=%{public}d", ret, channelId);
241 return ret;
242 }
243 char *anonymizePkgName = NULL;
244 Anonymize(pkgName, &anonymizePkgName);
245 TRANS_LOGI(TRANS_CTRL,
246 "trasn server on channel bind. pkgname=%{public}s, channelId=%{public}d, type=%{public}d",
247 AnonymizeWrapper(anonymizePkgName), channelId, channelType);
248 AnonymizeFree(anonymizePkgName);
249 return SOFTBUS_OK;
250 }
251
TransServerGetChannelCb(void)252 IServerChannelCallBack *TransServerGetChannelCb(void)
253 {
254 g_channelCallBack.OnChannelOpened = TransServerOnChannelOpened;
255 g_channelCallBack.OnChannelClosed = TransServerOnChannelClosed;
256 g_channelCallBack.OnChannelOpenFailed = TransServerOnChannelOpenFailed;
257 g_channelCallBack.OnDataReceived = TransServerOnMsgReceived;
258 g_channelCallBack.OnQosEvent = TransServerOnQosEvent;
259 g_channelCallBack.GetPkgNameBySessionName = TransGetPkgNameBySessionName;
260 g_channelCallBack.GetUidAndPidBySessionName = TransGetUidAndPid;
261 g_channelCallBack.OnChannelBind = TransServerOnChannelBind;
262 return &g_channelCallBack;
263 }
264
TransServerOnChannelLinkDown(const char * pkgName,int32_t pid,const LinkDownInfo * info)265 int32_t TransServerOnChannelLinkDown(const char *pkgName, int32_t pid, const LinkDownInfo *info)
266 {
267 if (pkgName == NULL || info == NULL || info->networkId == NULL) {
268 return SOFTBUS_INVALID_PARAM;
269 }
270 TRANS_LOGD(TRANS_CTRL, "pkgName=%{public}s", pkgName);
271
272 ChannelMsg data = {
273 .msgPid = pid,
274 .msgPkgName = pkgName,
275 .msgUuid = info->uuid,
276 .msgUdid = info->udid
277 };
278 if (ClientIpcOnChannelLinkDown(&data, info->networkId, info->peerIp, info->routeType) != SOFTBUS_OK) {
279 TRANS_LOGE(TRANS_CTRL, "client ipc on channel link down fail");
280 return SOFTBUS_IPC_ERR;
281 }
282 return SOFTBUS_OK;
283 }
284
285