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