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 "softbus_client_stub.h"
17
18 #include <string>
19
20 #include "client_bus_center_manager.h"
21 #include "client_trans_channel_callback.h"
22 #include "client_trans_session_manager.h"
23 #include "client_trans_socket_manager.h"
24 #include "comm_log.h"
25 #include "ipc_skeleton.h"
26 #include "ipc_types.h"
27 #include "message_parcel.h"
28 #include "securec.h"
29 #include "softbus_adapter_mem.h"
30 #include "softbus_def.h"
31 #include "softbus_errcode.h"
32 #include "softbus_server_ipc_interface_code.h"
33 #include "client_trans_udp_manager.h"
34
35 namespace OHOS {
SoftBusClientStub()36 SoftBusClientStub::SoftBusClientStub()
37 {
38 memberFuncMap_[CLIENT_ON_CHANNEL_OPENED] = &SoftBusClientStub::OnChannelOpenedInner;
39 memberFuncMap_[CLIENT_ON_CHANNEL_OPENFAILED] = &SoftBusClientStub::OnChannelOpenFailedInner;
40 memberFuncMap_[CLIENT_ON_CHANNEL_LINKDOWN] = &SoftBusClientStub::OnChannelLinkDownInner;
41 memberFuncMap_[CLIENT_ON_CHANNEL_CLOSED] = &SoftBusClientStub::OnChannelClosedInner;
42 memberFuncMap_[CLIENT_ON_CHANNEL_MSGRECEIVED] = &SoftBusClientStub::OnChannelMsgReceivedInner;
43 memberFuncMap_[CLIENT_ON_CHANNEL_QOSEVENT] = &SoftBusClientStub::OnChannelQosEventInner;
44 memberFuncMap_[CLIENT_ON_JOIN_RESULT] = &SoftBusClientStub::OnJoinLNNResultInner;
45 memberFuncMap_[CLIENT_ON_LEAVE_RESULT] = &SoftBusClientStub::OnLeaveLNNResultInner;
46 memberFuncMap_[CLIENT_ON_NODE_ONLINE_STATE_CHANGED] = &SoftBusClientStub::OnNodeOnlineStateChangedInner;
47 memberFuncMap_[CLIENT_ON_NODE_BASIC_INFO_CHANGED] = &SoftBusClientStub::OnNodeBasicInfoChangedInner;
48 memberFuncMap_[CLIENT_ON_NODE_STATUS_CHANGED] = &SoftBusClientStub::OnNodeStatusChangedInner;
49 memberFuncMap_[CLIENT_ON_LOCAL_NETWORK_ID_CHANGED] = &SoftBusClientStub::OnLocalNetworkIdChangedInner;
50 memberFuncMap_[CLIENT_ON_NODE_DEVICE_TRUST_CHANGED] = &SoftBusClientStub::OnNodeDeviceTrustedChangeInner;
51 memberFuncMap_[CLIENT_ON_HICHAIN_PROOF_EXCEPTION] = &SoftBusClientStub::OnHichainProofExceptionInner;
52 memberFuncMap_[CLIENT_ON_TIME_SYNC_RESULT] = &SoftBusClientStub::OnTimeSyncResultInner;
53 memberFuncMap_[CLIENT_ON_PUBLISH_LNN_RESULT] = &SoftBusClientStub::OnPublishLNNResultInner;
54 memberFuncMap_[CLIENT_ON_REFRESH_LNN_RESULT] = &SoftBusClientStub::OnRefreshLNNResultInner;
55 memberFuncMap_[CLIENT_ON_REFRESH_DEVICE_FOUND] = &SoftBusClientStub::OnRefreshDeviceFoundInner;
56 memberFuncMap_[CLIENT_ON_PERMISSION_CHANGE] = &SoftBusClientStub::OnClientPermissonChangeInner;
57 memberFuncMap_[CLIENT_SET_CHANNEL_INFO] = &SoftBusClientStub::SetChannelInfoInner;
58 memberFuncMap_[CLIENT_ON_DATA_LEVEL_CHANGED] = &SoftBusClientStub::OnDataLevelChangedInner;
59 memberFuncMap_[CLIENT_ON_TRANS_LIMIT_CHANGE] = &SoftBusClientStub::OnClientTransLimitChangeInner;
60 memberFuncMap_[CLIENT_ON_CHANNEL_BIND] = &SoftBusClientStub::OnChannelBindInner;
61 }
62
OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)63 int32_t SoftBusClientStub::OnRemoteRequest(uint32_t code,
64 MessageParcel &data, MessageParcel &reply, MessageOption &option)
65 {
66 COMM_LOGD(COMM_SDK, "SoftBusClientStub::OnReceived, code=%{public}u", code);
67 if (data.ReadInterfaceToken() != GetDescriptor()) {
68 COMM_LOGE(COMM_SDK, "SoftBusClientStub: ReadInterfaceToken faild!");
69 return SOFTBUS_TRANS_PROXY_READTOKEN_FAILED;
70 }
71 auto itFunc = memberFuncMap_.find(code);
72 if (itFunc != memberFuncMap_.end()) {
73 auto memberFunc = itFunc->second;
74 if (memberFunc != nullptr) {
75 return (this->*memberFunc)(data, reply);
76 }
77 }
78 COMM_LOGI(COMM_SDK, "SoftBusClientStub: default case, need check.");
79 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
80 }
81
OnClientPermissonChangeInner(MessageParcel &data, MessageParcel &reply)82 int32_t SoftBusClientStub::OnClientPermissonChangeInner(MessageParcel &data, MessageParcel &reply)
83 {
84 int32_t state;
85 COMM_CHECK_AND_RETURN_RET_LOGE(
86 data.ReadInt32(state), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read state failed");
87
88 const char *pkgName = data.ReadCString();
89 COMM_CHECK_AND_RETURN_RET_LOGE(
90 pkgName != nullptr, SOFTBUS_TRANS_PROXY_READCSTRING_FAILED, COMM_SDK, "read pkgName failed");
91
92 PermissionStateChange(pkgName, state);
93 return SOFTBUS_OK;
94 }
95
OnClientTransLimitChangeInner(MessageParcel &data, MessageParcel &reply)96 int32_t SoftBusClientStub::OnClientTransLimitChangeInner(MessageParcel &data, MessageParcel &reply)
97 {
98 int32_t channelId;
99 COMM_CHECK_AND_RETURN_RET_LOGE(
100 data.ReadInt32(channelId), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, COMM_SDK, "read channelId failed");
101
102 uint8_t tos;
103 COMM_CHECK_AND_RETURN_RET_LOGE(
104 data.ReadUint8(tos), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, COMM_SDK, "read tos failed");
105
106 int32_t ret = OnClientTransLimitChange(channelId, tos);
107 COMM_CHECK_AND_RETURN_RET_LOGE(
108 reply.WriteInt32(ret), SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED, COMM_SDK, "write reply failed");
109
110 return SOFTBUS_OK;
111 }
112
OnClientTransLimitChange(int32_t channelId, uint8_t tos)113 int32_t SoftBusClientStub::OnClientTransLimitChange(int32_t channelId, uint8_t tos)
114 {
115 return TransLimitChange(channelId, tos);
116 }
117
OnChannelOpened(const char *sessionName, const ChannelInfo *info)118 int32_t SoftBusClientStub::OnChannelOpened(const char *sessionName, const ChannelInfo *info)
119 {
120 return TransOnChannelOpened(sessionName, info);
121 }
122
OnChannelOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)123 int32_t SoftBusClientStub::OnChannelOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)
124 {
125 return TransOnChannelOpenFailed(channelId, channelType, errCode);
126 }
127
OnChannelLinkDown(const char *networkId, int32_t routeType)128 int32_t SoftBusClientStub::OnChannelLinkDown(const char *networkId, int32_t routeType)
129 {
130 return TransOnChannelLinkDown(networkId, routeType);
131 }
132
OnChannelClosed(int32_t channelId, int32_t channelType, int32_t messageType)133 int32_t SoftBusClientStub::OnChannelClosed(int32_t channelId, int32_t channelType, int32_t messageType)
134 {
135 return TransOnChannelClosed(channelId, channelType, messageType, SHUTDOWN_REASON_PEER);
136 }
137
OnChannelMsgReceived(int32_t channelId, int32_t channelType, const void *data, uint32_t len, int32_t type)138 int32_t SoftBusClientStub::OnChannelMsgReceived(int32_t channelId, int32_t channelType, const void *data,
139 uint32_t len, int32_t type)
140 {
141 return TransOnChannelMsgReceived(channelId, channelType, data, len, static_cast<SessionPktType>(type));
142 }
143
OnChannelQosEvent(int32_t channelId, int32_t channelType, int32_t eventId, int32_t tvCount, const QosTv *tvList)144 int32_t SoftBusClientStub::OnChannelQosEvent(int32_t channelId, int32_t channelType, int32_t eventId,
145 int32_t tvCount, const QosTv *tvList)
146 {
147 return TransOnChannelQosEvent(channelId, channelType, eventId, tvCount, tvList);
148 }
149
SetChannelInfo( const char *sessionName, int32_t sessionId, int32_t channelId, int32_t channelType)150 int32_t SoftBusClientStub::SetChannelInfo(
151 const char *sessionName, int32_t sessionId, int32_t channelId, int32_t channelType)
152 {
153 return TransSetChannelInfo(sessionName, sessionId, channelId, channelType);
154 }
155
MessageParcelRead(MessageParcel &data, ChannelInfo *channel)156 static int32_t MessageParcelRead(MessageParcel &data, ChannelInfo *channel)
157 {
158 READ_PARCEL_WITH_RET(data, Int32, channel->channelId, SOFTBUS_IPC_ERR);
159 READ_PARCEL_WITH_RET(data, Int32, channel->channelType, SOFTBUS_IPC_ERR);
160 READ_PARCEL_WITH_RET(data, Uint64, channel->laneId, SOFTBUS_IPC_ERR);
161 READ_PARCEL_WITH_RET(data, Int32, channel->connectType, SOFTBUS_IPC_ERR);
162 if (channel->channelType == CHANNEL_TYPE_TCP_DIRECT) {
163 channel->fd = data.ReadFileDescriptor();
164 channel->myIp = (char *)data.ReadCString();
165 COMM_CHECK_AND_RETURN_RET_LOGE(channel->myIp != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read myIp failed");
166 }
167 READ_PARCEL_WITH_RET(data, Bool, channel->isServer, SOFTBUS_IPC_ERR);
168 READ_PARCEL_WITH_RET(data, Bool, channel->isEnabled, SOFTBUS_IPC_ERR);
169 READ_PARCEL_WITH_RET(data, Bool, channel->isEncrypt, SOFTBUS_IPC_ERR);
170 READ_PARCEL_WITH_RET(data, Int32, channel->peerUid, SOFTBUS_IPC_ERR);
171 READ_PARCEL_WITH_RET(data, Int32, channel->peerPid, SOFTBUS_IPC_ERR);
172 channel->groupId = (char *)data.ReadCString();
173 COMM_CHECK_AND_RETURN_RET_LOGE(channel->groupId != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read groupId failed");
174 READ_PARCEL_WITH_RET(data, Uint32, channel->keyLen, SOFTBUS_IPC_ERR);
175 channel->sessionKey = (char *)data.ReadRawData(channel->keyLen);
176 COMM_CHECK_AND_RETURN_RET_LOGE(channel->sessionKey != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read rawData failed");
177 channel->peerSessionName = (char *)data.ReadCString();
178 COMM_CHECK_AND_RETURN_RET_LOGE(
179 channel->peerSessionName != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read peerSessionName failed");
180 channel->peerDeviceId = (char *)data.ReadCString();
181 COMM_CHECK_AND_RETURN_RET_LOGE(
182 channel->peerDeviceId != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read peerDeviceId failed");
183 READ_PARCEL_WITH_RET(data, Int32, channel->businessType, SOFTBUS_IPC_ERR);
184 if (channel->channelType == CHANNEL_TYPE_UDP) {
185 channel->myIp = (char *)data.ReadCString();
186 COMM_CHECK_AND_RETURN_RET_LOGE(channel->myIp != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read myIp failed");
187 READ_PARCEL_WITH_RET(data, Int32, channel->streamType, SOFTBUS_IPC_ERR);
188 READ_PARCEL_WITH_RET(data, Bool, channel->isUdpFile, SOFTBUS_IPC_ERR);
189 if (!channel->isServer) {
190 READ_PARCEL_WITH_RET(data, Int32, channel->peerPort, SOFTBUS_IPC_ERR);
191 channel->peerIp = (char *)data.ReadCString();
192 COMM_CHECK_AND_RETURN_RET_LOGE(
193 channel->peerIp != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read channel.peerIp failed");
194 }
195 }
196 READ_PARCEL_WITH_RET(data, Int32, channel->routeType, SOFTBUS_IPC_ERR);
197 READ_PARCEL_WITH_RET(data, Int32, channel->encrypt, SOFTBUS_IPC_ERR);
198 READ_PARCEL_WITH_RET(data, Int32, channel->algorithm, SOFTBUS_IPC_ERR);
199 READ_PARCEL_WITH_RET(data, Int32, channel->crc, SOFTBUS_IPC_ERR);
200 READ_PARCEL_WITH_RET(data, Uint32, channel->dataConfig, SOFTBUS_IPC_ERR);
201 READ_PARCEL_WITH_RET(data, Int32, channel->linkType, SOFTBUS_IPC_ERR);
202 READ_PARCEL_WITH_RET(data, Int32, channel->osType, SOFTBUS_IPC_ERR);
203 return SOFTBUS_OK;
204 }
205
OnChannelOpenedInner(MessageParcel &data, MessageParcel &reply)206 int32_t SoftBusClientStub::OnChannelOpenedInner(MessageParcel &data, MessageParcel &reply)
207 {
208 const char *sessionName = data.ReadCString();
209 COMM_CHECK_AND_RETURN_RET_LOGE(sessionName != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read sessionName failed");
210
211 ChannelInfo channel = { 0 };
212 int32_t ret = MessageParcelRead(data, &channel);
213 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, COMM_SDK, "read channel info failed");
214
215 ret = OnChannelOpened(sessionName, &channel);
216 COMM_CHECK_AND_RETURN_RET_LOGE(reply.WriteInt32(ret), SOFTBUS_IPC_ERR, COMM_SDK, "write reply failed");
217 return SOFTBUS_OK;
218 }
219
OnChannelOpenFailedInner(MessageParcel &data, MessageParcel &reply)220 int32_t SoftBusClientStub::OnChannelOpenFailedInner(MessageParcel &data, MessageParcel &reply)
221 {
222 int32_t channelId;
223 COMM_CHECK_AND_RETURN_RET_LOGE(
224 data.ReadInt32(channelId), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelId failed");
225
226 int32_t channelType;
227 COMM_CHECK_AND_RETURN_RET_LOGE(
228 data.ReadInt32(channelType), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelType failed");
229
230 int32_t errCode;
231 COMM_CHECK_AND_RETURN_RET_LOGE(
232 data.ReadInt32(errCode), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read errCode failed");
233
234 int32_t ret = OnChannelOpenFailed(channelId, channelType, errCode);
235 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, COMM_SDK, "OnChannelOpenFailed fail! ret=%{public}d", ret);
236
237 return SOFTBUS_OK;
238 }
239
OnChannelLinkDownInner(MessageParcel &data, MessageParcel &reply)240 int32_t SoftBusClientStub::OnChannelLinkDownInner(MessageParcel &data, MessageParcel &reply)
241 {
242 const char *networkId = data.ReadCString();
243 COMM_CHECK_AND_RETURN_RET_LOGE(
244 networkId != nullptr, SOFTBUS_TRANS_PROXY_READCSTRING_FAILED, COMM_SDK, "read networkId failed!");
245
246 COMM_LOGD(COMM_SDK, "SDK OnChannelMsgReceived");
247 int32_t routeType;
248 COMM_CHECK_AND_RETURN_RET_LOGE(
249 data.ReadInt32(routeType), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read routeType failed");
250
251 int32_t retReply = OnChannelLinkDown(networkId, routeType);
252 if (retReply != SOFTBUS_OK) {
253 COMM_LOGE(COMM_SDK, "OnChannelLinkDown proc error!");
254 }
255 return SOFTBUS_OK;
256 }
257
OnChannelClosedInner(MessageParcel &data, MessageParcel &reply)258 int32_t SoftBusClientStub::OnChannelClosedInner(MessageParcel &data, MessageParcel &reply)
259 {
260 int32_t channelId;
261 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelId), SOFTBUS_IPC_ERR, COMM_SDK, "read channelId failed");
262
263 int32_t channelType;
264 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelType), SOFTBUS_IPC_ERR, COMM_SDK, "read channelType failed");
265
266 int32_t messageType;
267 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(messageType), SOFTBUS_IPC_ERR, COMM_SDK, "read messageType failed");
268
269 int32_t ret = OnChannelClosed(channelId, channelType, messageType);
270 COMM_CHECK_AND_RETURN_RET_LOGE(reply.WriteInt32(ret), SOFTBUS_IPC_ERR, COMM_SDK, "write reply failed");
271
272 return SOFTBUS_OK;
273 }
274
OnChannelMsgReceivedInner(MessageParcel &data, MessageParcel &reply)275 int32_t SoftBusClientStub::OnChannelMsgReceivedInner(MessageParcel &data, MessageParcel &reply)
276 {
277 int32_t channelId;
278 COMM_CHECK_AND_RETURN_RET_LOGE(
279 data.ReadInt32(channelId), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelId failed");
280
281 int32_t channelType;
282 COMM_CHECK_AND_RETURN_RET_LOGE(
283 data.ReadInt32(channelType), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelType failed");
284
285 uint32_t len;
286 COMM_CHECK_AND_RETURN_RET_LOGE(
287 data.ReadUint32(len), SOFTBUS_TRANS_PROXY_READUINT_FAILED, COMM_SDK, "read data len failed");
288
289 char *dataInfo = (char *)data.ReadRawData(len);
290 COMM_CHECK_AND_RETURN_RET_LOGE(
291 dataInfo != nullptr, SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, COMM_SDK, "read dataInfo failed!");
292
293 int32_t type;
294 COMM_CHECK_AND_RETURN_RET_LOGE(
295 data.ReadInt32(type), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read type failed");
296
297 int ret = OnChannelMsgReceived(channelId, channelType, dataInfo, len, type);
298 COMM_CHECK_AND_RETURN_RET_LOGE(
299 reply.WriteInt32(ret), SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, COMM_SDK, "write reply failed");
300
301 return SOFTBUS_OK;
302 }
303
OnChannelQosEventInner(MessageParcel &data, MessageParcel &reply)304 int32_t SoftBusClientStub::OnChannelQosEventInner(MessageParcel &data, MessageParcel &reply)
305 {
306 COMM_LOGI(COMM_EVENT, "OnChannelQosEventInner");
307 int32_t channelId;
308 COMM_CHECK_AND_RETURN_RET_LOGE(
309 data.ReadInt32(channelId), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelId failed");
310
311 int32_t channelType;
312 COMM_CHECK_AND_RETURN_RET_LOGE(
313 data.ReadInt32(channelType), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelType failed");
314
315 int32_t eventId;
316 COMM_CHECK_AND_RETURN_RET_LOGE(
317 data.ReadInt32(eventId), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read eventId failed");
318
319 int32_t tvCount;
320 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(tvCount) && tvCount > 0, SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK,
321 "read tv failed! count=%{public}d", tvCount);
322
323 QosTv *tvList = (QosTv *)data.ReadRawData(sizeof(QosTv) * tvCount);
324 COMM_CHECK_AND_RETURN_RET_LOGE(
325 tvList != nullptr, SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, COMM_SDK, "read tv list failed!");
326
327 int ret = OnChannelQosEvent(channelId, channelType, eventId, tvCount, tvList);
328 COMM_CHECK_AND_RETURN_RET_LOGE(
329 reply.WriteInt32(ret), SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, COMM_SDK, "write reply failed");
330
331 return SOFTBUS_OK;
332 }
333
SetChannelInfoInner(MessageParcel &data, MessageParcel &reply)334 int32_t SoftBusClientStub::SetChannelInfoInner(MessageParcel &data, MessageParcel &reply)
335 {
336 const char *sessionName = data.ReadCString();
337 COMM_CHECK_AND_RETURN_RET_LOGE(sessionName != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read sessionName failed");
338
339 int32_t sessionId;
340 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(sessionId), SOFTBUS_IPC_ERR, COMM_SDK, "read sessionId failed");
341
342 int32_t channelId;
343 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelId), SOFTBUS_IPC_ERR, COMM_SDK, "read channelId failed");
344
345 int32_t channelType;
346 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelType), SOFTBUS_IPC_ERR, COMM_SDK, "read channelType failed");
347
348 int ret = SetChannelInfo(sessionName, sessionId, channelId, channelType);
349 COMM_CHECK_AND_RETURN_RET_LOGE(
350 reply.WriteInt32(ret), SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, COMM_SDK, "write reply failed");
351
352 return SOFTBUS_OK;
353 }
354
OnJoinLNNResultInner(MessageParcel &data, MessageParcel &reply)355 int32_t SoftBusClientStub::OnJoinLNNResultInner(MessageParcel &data, MessageParcel &reply)
356 {
357 uint32_t addrTypeLen;
358 if (!data.ReadUint32(addrTypeLen) || addrTypeLen != sizeof(ConnectionAddr)) {
359 COMM_LOGE(COMM_SDK, "OnJoinLNNResultInner read addr type failed! length=%{public}d", addrTypeLen);
360 return SOFTBUS_TRANS_PROXY_READUINT_FAILED;
361 }
362 void *addr = (void *)data.ReadRawData(addrTypeLen);
363 if (addr == nullptr) {
364 COMM_LOGE(COMM_SDK, "OnJoinLNNResultInner read addr failed!");
365 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
366 }
367 int32_t retCode;
368 if (!data.ReadInt32(retCode)) {
369 COMM_LOGE(COMM_SDK, "OnJoinLNNResultInner read retCode failed!");
370 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
371 }
372 const char *networkId = nullptr;
373 if (retCode == 0) {
374 networkId = data.ReadCString();
375 if (networkId == nullptr) {
376 COMM_LOGE(COMM_SDK, "OnJoinLNNResultInner read networkId failed!");
377 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
378 }
379 }
380 int32_t retReply = OnJoinLNNResult(addr, addrTypeLen, networkId, retCode);
381 if (retReply != SOFTBUS_OK) {
382 COMM_LOGE(COMM_SDK, "OnJoinLNNResultInner notify join result failed!");
383 }
384 return SOFTBUS_OK;
385 }
386
OnLeaveLNNResultInner(MessageParcel &data, MessageParcel &reply)387 int32_t SoftBusClientStub::OnLeaveLNNResultInner(MessageParcel &data, MessageParcel &reply)
388 {
389 const char *networkId = data.ReadCString();
390 if (networkId == nullptr) {
391 COMM_LOGE(COMM_SDK, "OnLeaveLNNResultInner read networkId failed!");
392 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
393 }
394 int32_t retCode;
395 if (!data.ReadInt32(retCode)) {
396 COMM_LOGE(COMM_SDK, "OnLeaveLNNResultInner read retCode failed!");
397 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
398 }
399 int32_t retReply = OnLeaveLNNResult(networkId, retCode);
400 if (retReply != SOFTBUS_OK) {
401 COMM_LOGE(COMM_SDK, "OnLeaveLNNResultInner notify leave result failed!");
402 }
403 return SOFTBUS_OK;
404 }
405
OnNodeOnlineStateChangedInner(MessageParcel &data, MessageParcel &reply)406 int32_t SoftBusClientStub::OnNodeOnlineStateChangedInner(MessageParcel &data, MessageParcel &reply)
407 {
408 const char *pkgName = data.ReadCString();
409 if (pkgName == nullptr || strlen(pkgName) == 0) {
410 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
411 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
412 }
413 bool isOnline = false;
414 if (!data.ReadBool(isOnline)) {
415 COMM_LOGE(COMM_SDK, "OnNodeOnlineStateChangedInner read online state failed!");
416 return SOFTBUS_TRANS_PROXY_READBOOL_FAILED;
417 }
418 uint32_t infoTypeLen;
419 if (!data.ReadUint32(infoTypeLen) || infoTypeLen != sizeof(NodeBasicInfo)) {
420 COMM_LOGE(COMM_SDK, "OnNodeOnlineStateChangedInner read info type failed! length=%{public}d", infoTypeLen);
421 return SOFTBUS_TRANS_PROXY_READUINT_FAILED;
422 }
423 void *info = (void *)data.ReadRawData(infoTypeLen);
424 if (info == nullptr) {
425 COMM_LOGE(COMM_SDK, "OnNodeOnlineStateChangedInner read basic info failed!");
426 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
427 }
428 int32_t retReply = OnNodeOnlineStateChanged(pkgName, isOnline, info, infoTypeLen);
429 COMM_LOGI(COMM_SDK, "notify complete, pkgName=%{public}s, isOnline=%{public}d", pkgName, isOnline);
430 if (!reply.WriteInt32(retReply)) {
431 COMM_LOGE(COMM_SDK, "OnNodeOnlineStateChangedInner write reply failed!");
432 return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
433 }
434 return SOFTBUS_OK;
435 }
436
OnNodeBasicInfoChangedInner(MessageParcel &data, MessageParcel &reply)437 int32_t SoftBusClientStub::OnNodeBasicInfoChangedInner(MessageParcel &data, MessageParcel &reply)
438 {
439 const char *pkgName = data.ReadCString();
440 if (pkgName == nullptr || strlen(pkgName) == 0) {
441 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
442 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
443 }
444 int32_t type;
445 if (!data.ReadInt32(type)) {
446 COMM_LOGE(COMM_SDK, "OnNodeBasicInfoChangedInner read type failed!");
447 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
448 }
449 COMM_LOGD(COMM_SDK, "OnNodeBasicInfoChangedInner type. type=%{public}d", type);
450 uint32_t infoTypeLen;
451 if (!data.ReadUint32(infoTypeLen) || infoTypeLen != sizeof(NodeBasicInfo)) {
452 COMM_LOGE(COMM_SDK, "OnNodeBasicInfoChangedInner read failed! infoTypeLen=%{public}d", infoTypeLen);
453 return SOFTBUS_TRANS_PROXY_READUINT_FAILED;
454 }
455 void *info = (void *)data.ReadRawData(infoTypeLen);
456 if (info == nullptr) {
457 COMM_LOGE(COMM_SDK, "OnNodeBasicInfoChangedInner read basic info failed!");
458 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
459 }
460 int32_t retReply = OnNodeBasicInfoChanged(pkgName, info, infoTypeLen, type);
461 if (!reply.WriteInt32(retReply)) {
462 COMM_LOGE(COMM_SDK, "OnNodeBasicInfoChangedInner write reply failed!");
463 return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
464 }
465 return SOFTBUS_OK;
466 }
467
OnNodeStatusChangedInner(MessageParcel &data, MessageParcel &reply)468 int32_t SoftBusClientStub::OnNodeStatusChangedInner(MessageParcel &data, MessageParcel &reply)
469 {
470 const char *pkgName = data.ReadCString();
471 if (pkgName == nullptr || strlen(pkgName) == 0) {
472 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
473 return SOFTBUS_INVALID_PARAM;
474 }
475 int32_t type;
476 if (!data.ReadInt32(type)) {
477 COMM_LOGE(COMM_SDK, "OnNodeStatusChangedInner read type failed!");
478 return SOFTBUS_NETWORK_READINT32_FAILED;
479 }
480 COMM_LOGD(COMM_SDK, "OnNodeStatusChangedInner type=%{public}d", type);
481 uint32_t infoTypeLen;
482 if (!data.ReadUint32(infoTypeLen) || infoTypeLen != sizeof(NodeStatus)) {
483 COMM_LOGE(COMM_SDK, "OnNodeStatusChangedInner read failed! infoTypeLen=%{public}d", infoTypeLen);
484 return SOFTBUS_NETWORK_READINT32_FAILED;
485 }
486 void *info = (void *)data.ReadRawData(infoTypeLen);
487 if (info == nullptr) {
488 COMM_LOGE(COMM_SDK, "OnNodeStatusChangedInner read node status failed!");
489 return SOFTBUS_NETWORK_READRAWDATA_FAILED;
490 }
491 int32_t retReply = OnNodeStatusChanged(pkgName, info, infoTypeLen, type);
492 if (!reply.WriteInt32(retReply)) {
493 COMM_LOGE(COMM_SDK, "OnNodeStatusChangedInner write reply failed!");
494 return SOFTBUS_NETWORK_WRITEINT32_FAILED;
495 }
496 return SOFTBUS_OK;
497 }
498
OnLocalNetworkIdChangedInner(MessageParcel &data, MessageParcel &reply)499 int32_t SoftBusClientStub::OnLocalNetworkIdChangedInner(MessageParcel &data, MessageParcel &reply)
500 {
501 const char *pkgName = data.ReadCString();
502 if (pkgName == nullptr || strlen(pkgName) == 0) {
503 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
504 return SOFTBUS_INVALID_PARAM;
505 }
506 int32_t retReply = OnLocalNetworkIdChanged(pkgName);
507 if (!reply.WriteInt32(retReply)) {
508 COMM_LOGE(COMM_SDK, "OnLocalNetworkIdChangedInner write reply failed!");
509 return SOFTBUS_IPC_ERR;
510 }
511 return SOFTBUS_OK;
512 }
513
OnNodeDeviceTrustedChangeInner(MessageParcel &data, MessageParcel &reply)514 int32_t SoftBusClientStub::OnNodeDeviceTrustedChangeInner(MessageParcel &data, MessageParcel &reply)
515 {
516 const char *pkgName = data.ReadCString();
517 if (pkgName == nullptr || strlen(pkgName) == 0) {
518 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
519 return SOFTBUS_INVALID_PARAM;
520 }
521 int32_t type = 0;
522 if (!data.ReadInt32(type)) {
523 COMM_LOGE(COMM_SDK, "read type failed!");
524 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
525 }
526 const char *msg = data.ReadCString();
527 if (msg == nullptr) {
528 COMM_LOGE(COMM_SDK, "read msg failed!");
529 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
530 }
531 uint32_t msgLen = 0;
532 if (!data.ReadUint32(msgLen)) {
533 COMM_LOGE(COMM_SDK, "read failed! msgLen=%{public}u", msgLen);
534 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
535 }
536 int32_t retReply = OnNodeDeviceTrustedChange(pkgName, type, msg, msgLen);
537 if (!reply.WriteInt32(retReply)) {
538 COMM_LOGE(COMM_SDK, "write reply failed!");
539 return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
540 }
541 return SOFTBUS_OK;
542 }
543
OnHichainProofExceptionInner(MessageParcel &data, MessageParcel &reply)544 int32_t SoftBusClientStub::OnHichainProofExceptionInner(MessageParcel &data, MessageParcel &reply)
545 {
546 const char *pkgName = data.ReadCString();
547 if (pkgName == nullptr || strlen(pkgName) == 0) {
548 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
549 return SOFTBUS_INVALID_PARAM;
550 }
551 uint32_t deviceListLen = 0;
552 if (!data.ReadUint32(deviceListLen)) {
553 COMM_LOGE(COMM_SDK, "read failed! deviceListLen=%{public}u", deviceListLen);
554 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
555 }
556 char *deviceList = NULL;
557 if (deviceListLen != 0) {
558 deviceList = (char *)data.ReadRawData(deviceListLen);
559 if (deviceList == nullptr) {
560 COMM_LOGE(COMM_SDK, "read deviceList failed!");
561 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
562 }
563 }
564 uint16_t deviceTypeId = 0;
565 if (!data.ReadUint16(deviceTypeId)) {
566 COMM_LOGE(COMM_SDK, "read failed! deviceTypeId=%{public}hu", deviceTypeId);
567 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
568 }
569 int32_t errCode = 0;
570 if (!data.ReadInt32(errCode)) {
571 COMM_LOGE(COMM_SDK, "read failed! errCode=%{public}d", errCode);
572 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
573 }
574 int32_t retReply = OnHichainProofException(pkgName, deviceList, deviceListLen, deviceTypeId, errCode);
575 if (!reply.WriteInt32(retReply)) {
576 COMM_LOGE(COMM_SDK, "OnHichainProofException write reply failed!");
577 return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
578 }
579 return SOFTBUS_OK;
580 }
581
OnTimeSyncResultInner(MessageParcel &data, MessageParcel &reply)582 int32_t SoftBusClientStub::OnTimeSyncResultInner(MessageParcel &data, MessageParcel &reply)
583 {
584 uint32_t infoTypeLen;
585 if (!data.ReadUint32(infoTypeLen) || infoTypeLen != sizeof(TimeSyncResultInfo)) {
586 COMM_LOGE(COMM_SDK, "OnTimeSyncResultInner read info failed! length=%{public}d", infoTypeLen);
587 return SOFTBUS_TRANS_PROXY_READUINT_FAILED;
588 }
589 void *info = (void *)data.ReadRawData(infoTypeLen);
590 if (info == nullptr) {
591 COMM_LOGE(COMM_SDK, "OnTimeSyncResultInner read info failed!");
592 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
593 }
594 int32_t retCode;
595 if (!data.ReadInt32(retCode)) {
596 COMM_LOGE(COMM_SDK, "OnTimeSyncResultInner read retCode failed!");
597 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
598 }
599
600 int32_t retReply = OnTimeSyncResult(info, infoTypeLen, retCode);
601 if (!reply.WriteInt32(retReply)) {
602 COMM_LOGE(COMM_SDK, "OnTimeSyncResultInner write reply failed!");
603 return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
604 }
605 return SOFTBUS_OK;
606 }
607
OnPublishLNNResultInner(MessageParcel &data, MessageParcel &reply)608 int32_t SoftBusClientStub::OnPublishLNNResultInner(MessageParcel &data, MessageParcel &reply)
609 {
610 int32_t publishId;
611 if (!data.ReadInt32(publishId)) {
612 COMM_LOGE(COMM_SDK, "OnPublishLNNResultInner read publishId failed!");
613 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
614 }
615 int32_t reason;
616 if (!data.ReadInt32(reason)) {
617 COMM_LOGE(COMM_SDK, "OnPublishLNNResultInner read reason failed!");
618 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
619 }
620
621 OnPublishLNNResult(publishId, reason);
622 return SOFTBUS_OK;
623 }
624
OnRefreshLNNResultInner(MessageParcel &data, MessageParcel &reply)625 int32_t SoftBusClientStub::OnRefreshLNNResultInner(MessageParcel &data, MessageParcel &reply)
626 {
627 int32_t refreshId;
628 if (!data.ReadInt32(refreshId)) {
629 COMM_LOGE(COMM_SDK, "OnRefreshLNNResultInner read publishId failed!");
630 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
631 }
632 int32_t reason;
633 if (!data.ReadInt32(reason)) {
634 COMM_LOGE(COMM_SDK, "OnRefreshLNNResultInner read reason failed!");
635 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
636 }
637
638 OnRefreshLNNResult(refreshId, reason);
639 return SOFTBUS_OK;
640 }
641
OnRefreshDeviceFoundInner(MessageParcel &data, MessageParcel &reply)642 int32_t SoftBusClientStub::OnRefreshDeviceFoundInner(MessageParcel &data, MessageParcel &reply)
643 {
644 uint32_t deviceLen;
645 if (!data.ReadUint32(deviceLen) || deviceLen != sizeof(DeviceInfo)) {
646 COMM_LOGE(COMM_SDK, "OnRefreshDeviceFoundInner read info failed! length=%{public}d", deviceLen);
647 return SOFTBUS_TRANS_PROXY_READUINT_FAILED;
648 }
649 void *device = (void *)data.ReadRawData(deviceLen);
650 if (device == nullptr) {
651 COMM_LOGE(COMM_SDK, "OnRefreshDeviceFoundInner read info failed!");
652 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
653 }
654 OnRefreshDeviceFound(device, deviceLen);
655 return SOFTBUS_OK;
656 }
657
OnDataLevelChangedInner(MessageParcel &data, MessageParcel &reply)658 int32_t SoftBusClientStub::OnDataLevelChangedInner(MessageParcel &data, MessageParcel &reply)
659 {
660 const char *networkId = data.ReadCString();
661 if (networkId == nullptr || strlen(networkId) == 0) {
662 COMM_LOGE(COMM_SDK, "Invalid network, or length is zero");
663 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
664 }
665
666 DataLevelInfo *info = (DataLevelInfo *)data.ReadRawData(sizeof(DataLevelInfo));
667 if (info == nullptr) {
668 COMM_LOGE(COMM_SDK, "OnDataLevelChangedInner read data level chagne info failed");
669 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
670 }
671 OnDataLevelChanged(networkId, info);
672 return SOFTBUS_OK;
673 }
674
OnChannelBind(int32_t channelId, int32_t channelType)675 int32_t SoftBusClientStub::OnChannelBind(int32_t channelId, int32_t channelType)
676 {
677 return TransOnChannelBind(channelId, channelType);
678 }
679
OnChannelBindInner(MessageParcel &data, MessageParcel &reply)680 int32_t SoftBusClientStub::OnChannelBindInner(MessageParcel &data, MessageParcel &reply)
681 {
682 int32_t channelId;
683 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelId), SOFTBUS_IPC_ERR, COMM_SDK, "read channelId failed");
684
685 int32_t channelType;
686 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelType), SOFTBUS_IPC_ERR, COMM_SDK, "read channelType failed");
687
688 int32_t ret = OnChannelBind(channelId, channelType);
689 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, COMM_SDK,
690 "OnChannelBind failed! ret=%{public}d, channelId=%{public}d, channelType=%{public}d",
691 ret, channelId, channelType);
692
693 return SOFTBUS_OK;
694 }
695
OnJoinLNNResult(void *addr, uint32_t addrTypeLen, const char *networkId, int retCode)696 int32_t SoftBusClientStub::OnJoinLNNResult(void *addr, uint32_t addrTypeLen, const char *networkId, int retCode)
697 {
698 (void)addrTypeLen;
699 return LnnOnJoinResult(addr, networkId, retCode);
700 }
701
OnLeaveLNNResult(const char *networkId, int retCode)702 int32_t SoftBusClientStub::OnLeaveLNNResult(const char *networkId, int retCode)
703 {
704 return LnnOnLeaveResult(networkId, retCode);
705 }
706
OnNodeOnlineStateChanged(const char *pkgName, bool isOnline, void *info, uint32_t infoTypeLen)707 int32_t SoftBusClientStub::OnNodeOnlineStateChanged(const char *pkgName, bool isOnline,
708 void *info, uint32_t infoTypeLen)
709 {
710 (void)infoTypeLen;
711 return LnnOnNodeOnlineStateChanged(pkgName, isOnline, info);
712 }
713
OnNodeBasicInfoChanged(const char *pkgName, void *info, uint32_t infoTypeLen, int32_t type)714 int32_t SoftBusClientStub::OnNodeBasicInfoChanged(const char *pkgName, void *info, uint32_t infoTypeLen, int32_t type)
715 {
716 (void)infoTypeLen;
717 return LnnOnNodeBasicInfoChanged(pkgName, info, type);
718 }
719
OnNodeStatusChanged(const char *pkgName, void *info, uint32_t infoTypeLen, int32_t type)720 int32_t SoftBusClientStub::OnNodeStatusChanged(const char *pkgName, void *info, uint32_t infoTypeLen, int32_t type)
721 {
722 (void)infoTypeLen;
723 return LnnOnNodeStatusChanged(pkgName, info, type);
724 }
725
OnLocalNetworkIdChanged(const char *pkgName)726 int32_t SoftBusClientStub::OnLocalNetworkIdChanged(const char *pkgName)
727 {
728 return LnnOnLocalNetworkIdChanged(pkgName);
729 }
730
OnNodeDeviceTrustedChange(const char *pkgName, int32_t type, const char *msg, uint32_t msgLen)731 int32_t SoftBusClientStub::OnNodeDeviceTrustedChange(const char *pkgName, int32_t type, const char *msg,
732 uint32_t msgLen)
733 {
734 return LnnOnNodeDeviceTrustedChange(pkgName, type, msg, msgLen);
735 }
736
OnHichainProofException( const char *pkgName, const char *deviceList, uint32_t deviceListLen, uint16_t deviceTypeId, int32_t errCode)737 int32_t SoftBusClientStub::OnHichainProofException(
738 const char *pkgName, const char *deviceList, uint32_t deviceListLen, uint16_t deviceTypeId, int32_t errCode)
739 {
740 return LnnOnHichainProofException(pkgName, deviceList, deviceListLen, deviceTypeId, errCode);
741 }
742
OnTimeSyncResult(const void *info, uint32_t infoTypeLen, int32_t retCode)743 int32_t SoftBusClientStub::OnTimeSyncResult(const void *info, uint32_t infoTypeLen, int32_t retCode)
744 {
745 (void)infoTypeLen;
746 return LnnOnTimeSyncResult(info, retCode);
747 }
748
OnPublishLNNResult(int32_t publishId, int32_t reason)749 void SoftBusClientStub::OnPublishLNNResult(int32_t publishId, int32_t reason)
750 {
751 LnnOnPublishLNNResult(publishId, reason);
752 }
753
OnRefreshLNNResult(int32_t refreshId, int32_t reason)754 void SoftBusClientStub::OnRefreshLNNResult(int32_t refreshId, int32_t reason)
755 {
756 LnnOnRefreshLNNResult(refreshId, reason);
757 }
758
OnRefreshDeviceFound(const void *device, uint32_t deviceLen)759 void SoftBusClientStub::OnRefreshDeviceFound(const void *device, uint32_t deviceLen)
760 {
761 (void)deviceLen;
762 LnnOnRefreshDeviceFound(device);
763 }
764
OnDataLevelChanged(const char *networkId, const DataLevelInfo *dataLevelInfo)765 void SoftBusClientStub::OnDataLevelChanged(const char *networkId, const DataLevelInfo *dataLevelInfo)
766 {
767 LnnOnDataLevelChanged(networkId, dataLevelInfo);
768 }
769 } // namespace OHOS
770