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