1 /*
2 * Copyright (c) 2021-2025 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 "anonymizer.h"
19 #include "client_bus_center_manager.h"
20 #include "client_trans_channel_callback.h"
21 #include "client_trans_socket_manager.h"
22 #include "securec.h"
23 #include "session_set_timer.h"
24 #include "softbus_server_ipc_interface_code.h"
25 #include "client_trans_udp_manager.h"
26
27 namespace OHOS {
28 static constexpr uint32_t DFX_TIMERS_S = 15;
29
SoftBusClientStub()30 SoftBusClientStub::SoftBusClientStub()
31 {
32 memberFuncMap_[CLIENT_ON_CHANNEL_OPENED] = &SoftBusClientStub::OnChannelOpenedInner;
33 memberFuncMap_[CLIENT_ON_CHANNEL_OPENFAILED] = &SoftBusClientStub::OnChannelOpenFailedInner;
34 memberFuncMap_[CLIENT_ON_CHANNEL_LINKDOWN] = &SoftBusClientStub::OnChannelLinkDownInner;
35 memberFuncMap_[CLIENT_ON_CHANNEL_CLOSED] = &SoftBusClientStub::OnChannelClosedInner;
36 memberFuncMap_[CLIENT_ON_CHANNEL_MSGRECEIVED] = &SoftBusClientStub::OnChannelMsgReceivedInner;
37 memberFuncMap_[CLIENT_ON_CHANNEL_QOSEVENT] = &SoftBusClientStub::OnChannelQosEventInner;
38 memberFuncMap_[CLIENT_ON_JOIN_RESULT] = &SoftBusClientStub::OnJoinLNNResultInner;
39 memberFuncMap_[CLIENT_ON_LEAVE_RESULT] = &SoftBusClientStub::OnLeaveLNNResultInner;
40 memberFuncMap_[CLIENT_ON_NODE_ONLINE_STATE_CHANGED] = &SoftBusClientStub::OnNodeOnlineStateChangedInner;
41 memberFuncMap_[CLIENT_ON_NODE_BASIC_INFO_CHANGED] = &SoftBusClientStub::OnNodeBasicInfoChangedInner;
42 memberFuncMap_[CLIENT_ON_NODE_STATUS_CHANGED] = &SoftBusClientStub::OnNodeStatusChangedInner;
43 memberFuncMap_[CLIENT_ON_LOCAL_NETWORK_ID_CHANGED] = &SoftBusClientStub::OnLocalNetworkIdChangedInner;
44 memberFuncMap_[CLIENT_ON_NODE_DEVICE_TRUST_CHANGED] = &SoftBusClientStub::OnNodeDeviceTrustedChangeInner;
45 memberFuncMap_[CLIENT_ON_HICHAIN_PROOF_EXCEPTION] = &SoftBusClientStub::OnHichainProofExceptionInner;
46 memberFuncMap_[CLIENT_ON_TIME_SYNC_RESULT] = &SoftBusClientStub::OnTimeSyncResultInner;
47 memberFuncMap_[CLIENT_ON_PUBLISH_LNN_RESULT] = &SoftBusClientStub::OnPublishLNNResultInner;
48 memberFuncMap_[CLIENT_ON_REFRESH_LNN_RESULT] = &SoftBusClientStub::OnRefreshLNNResultInner;
49 memberFuncMap_[CLIENT_ON_REFRESH_DEVICE_FOUND] = &SoftBusClientStub::OnRefreshDeviceFoundInner;
50 memberFuncMap_[CLIENT_ON_PERMISSION_CHANGE] = &SoftBusClientStub::OnClientPermissonChangeInner;
51 memberFuncMap_[CLIENT_SET_CHANNEL_INFO] = &SoftBusClientStub::SetChannelInfoInner;
52 memberFuncMap_[CLIENT_ON_DATA_LEVEL_CHANGED] = &SoftBusClientStub::OnDataLevelChangedInner;
53 memberFuncMap_[CLIENT_ON_BLE_RANGE_DONE] = &SoftBusClientStub::OnBleRangeDoneInner;
54 memberFuncMap_[CLIENT_ON_TRANS_LIMIT_CHANGE] = &SoftBusClientStub::OnClientTransLimitChangeInner;
55 memberFuncMap_[CLIENT_ON_CHANNEL_BIND] = &SoftBusClientStub::OnChannelBindInner;
56 memberFuncMap_[CLIENT_CHANNEL_ON_QOS] = &SoftBusClientStub::OnChannelOnQosInner;
57 memberFuncMap_[CLIENT_CHECK_COLLAB_RELATION] = &SoftBusClientStub::OnCheckCollabRelationInner;
58 }
59
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)60 int32_t SoftBusClientStub::OnRemoteRequest(uint32_t code,
61 MessageParcel &data, MessageParcel &reply, MessageOption &option)
62 {
63 COMM_LOGD(COMM_SDK, "SoftBusClientStub::OnReceived, code=%{public}u", code);
64 if (data.ReadInterfaceToken() != GetDescriptor()) {
65 COMM_LOGE(COMM_SDK, "SoftBusClientStub: ReadInterfaceToken faild!");
66 return SOFTBUS_TRANS_PROXY_READTOKEN_FAILED;
67 }
68 auto itFunc = memberFuncMap_.find(code);
69 if (itFunc != memberFuncMap_.end()) {
70 auto memberFunc = itFunc->second;
71 if (memberFunc != nullptr) {
72 return (this->*memberFunc)(data, reply);
73 }
74 }
75 COMM_LOGI(COMM_SDK, "SoftBusClientStub: default case, need check.");
76 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
77 }
78
OnClientPermissonChangeInner(MessageParcel & data,MessageParcel & reply)79 int32_t SoftBusClientStub::OnClientPermissonChangeInner(MessageParcel &data, MessageParcel &reply)
80 {
81 int32_t state;
82 COMM_CHECK_AND_RETURN_RET_LOGE(
83 data.ReadInt32(state), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read state failed");
84
85 const char *pkgName = data.ReadCString();
86 COMM_CHECK_AND_RETURN_RET_LOGE(
87 pkgName != nullptr, SOFTBUS_TRANS_PROXY_READCSTRING_FAILED, COMM_SDK, "read pkgName failed");
88
89 PermissionStateChange(pkgName, state);
90 return SOFTBUS_OK;
91 }
92
OnClientTransLimitChangeInner(MessageParcel & data,MessageParcel & reply)93 int32_t SoftBusClientStub::OnClientTransLimitChangeInner(MessageParcel &data, MessageParcel &reply)
94 {
95 int32_t channelId;
96 COMM_CHECK_AND_RETURN_RET_LOGE(
97 data.ReadInt32(channelId), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, COMM_SDK, "read channelId failed");
98
99 uint8_t tos;
100 COMM_CHECK_AND_RETURN_RET_LOGE(
101 data.ReadUint8(tos), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, COMM_SDK, "read tos failed");
102
103 int32_t ret = OnClientTransLimitChange(channelId, tos);
104 COMM_CHECK_AND_RETURN_RET_LOGE(
105 reply.WriteInt32(ret), SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED, COMM_SDK, "write reply failed");
106
107 return SOFTBUS_OK;
108 }
109
OnClientTransLimitChange(int32_t channelId,uint8_t tos)110 int32_t SoftBusClientStub::OnClientTransLimitChange(int32_t channelId, uint8_t tos)
111 {
112 return TransLimitChange(channelId, tos);
113 }
114
OnChannelOpened(const char * sessionName,const ChannelInfo * info)115 int32_t SoftBusClientStub::OnChannelOpened(const char *sessionName, const ChannelInfo *info)
116 {
117 int32_t id = SetTimer("OnChannelOpened", DFX_TIMERS_S);
118 int32_t ret = TransOnChannelOpened(sessionName, info);
119 CancelTimer(id);
120 return ret;
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
MessageTcpParcelRead(MessageParcel & data,ChannelInfo * channel)156 static int32_t MessageTcpParcelRead(MessageParcel &data, ChannelInfo *channel)
157 {
158 if (channel->channelType == CHANNEL_TYPE_TCP_DIRECT) {
159 channel->fd = data.ReadFileDescriptor();
160 channel->myIp = (char *)data.ReadCString();
161 COMM_CHECK_AND_RETURN_RET_LOGE(channel->myIp != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read myIp failed");
162 }
163 return SOFTBUS_OK;
164 }
165
MessageParcelRead(MessageParcel & data,ChannelInfo * channel)166 static int32_t MessageParcelRead(MessageParcel &data, ChannelInfo *channel)
167 {
168 READ_PARCEL_WITH_RET(data, Int32, channel->channelId, SOFTBUS_IPC_ERR);
169 READ_PARCEL_WITH_RET(data, Int32, channel->channelType, SOFTBUS_IPC_ERR);
170 READ_PARCEL_WITH_RET(data, Uint64, channel->laneId, SOFTBUS_IPC_ERR);
171 READ_PARCEL_WITH_RET(data, Int32, channel->connectType, SOFTBUS_IPC_ERR);
172 int32_t ret = MessageTcpParcelRead(data, channel);
173 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_IPC_ERR, COMM_SDK, "read tcp ip or fd failed");
174 READ_PARCEL_WITH_RET(data, Bool, channel->isServer, SOFTBUS_IPC_ERR);
175 READ_PARCEL_WITH_RET(data, Bool, channel->isEnabled, SOFTBUS_IPC_ERR);
176 READ_PARCEL_WITH_RET(data, Bool, channel->isEncrypt, SOFTBUS_IPC_ERR);
177 READ_PARCEL_WITH_RET(data, Int32, channel->peerUid, SOFTBUS_IPC_ERR);
178 READ_PARCEL_WITH_RET(data, Int32, channel->peerPid, SOFTBUS_IPC_ERR);
179 channel->groupId = (char *)data.ReadCString();
180 COMM_CHECK_AND_RETURN_RET_LOGE(channel->groupId != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read groupId failed");
181 COMM_CHECK_AND_RETURN_RET_LOGE(channel->keyLen <= SESSION_KEY_LENGTH, SOFTBUS_IPC_ERR, COMM_SDK,
182 "channel->keyLen invalid");
183 READ_PARCEL_WITH_RET(data, Uint32, channel->keyLen, SOFTBUS_IPC_ERR);
184 channel->sessionKey = (char *)data.ReadRawData(channel->keyLen);
185 COMM_CHECK_AND_RETURN_RET_LOGE(channel->sessionKey != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read rawData failed");
186 channel->peerSessionName = (char *)data.ReadCString();
187 COMM_CHECK_AND_RETURN_RET_LOGE(
188 channel->peerSessionName != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read peerSessionName failed");
189 channel->peerDeviceId = (char *)data.ReadCString();
190 COMM_CHECK_AND_RETURN_RET_LOGE(
191 channel->peerDeviceId != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read peerDeviceId failed");
192 READ_PARCEL_WITH_RET(data, Int32, channel->businessType, SOFTBUS_IPC_ERR);
193 if (channel->channelType == CHANNEL_TYPE_UDP) {
194 channel->myIp = (char *)data.ReadCString();
195 COMM_CHECK_AND_RETURN_RET_LOGE(channel->myIp != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read myIp failed");
196 READ_PARCEL_WITH_RET(data, Int32, channel->streamType, SOFTBUS_IPC_ERR);
197 READ_PARCEL_WITH_RET(data, Bool, channel->isUdpFile, SOFTBUS_IPC_ERR);
198 if (!channel->isServer) {
199 READ_PARCEL_WITH_RET(data, Int32, channel->peerPort, SOFTBUS_IPC_ERR);
200 channel->peerIp = (char *)data.ReadCString();
201 COMM_CHECK_AND_RETURN_RET_LOGE(
202 channel->peerIp != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read channel.peerIp failed");
203 }
204 }
205 READ_PARCEL_WITH_RET(data, Int32, channel->routeType, SOFTBUS_IPC_ERR);
206 READ_PARCEL_WITH_RET(data, Int32, channel->encrypt, SOFTBUS_IPC_ERR);
207 READ_PARCEL_WITH_RET(data, Int32, channel->algorithm, SOFTBUS_IPC_ERR);
208 READ_PARCEL_WITH_RET(data, Int32, channel->crc, SOFTBUS_IPC_ERR);
209 READ_PARCEL_WITH_RET(data, Uint32, channel->dataConfig, SOFTBUS_IPC_ERR);
210 READ_PARCEL_WITH_RET(data, Int32, channel->linkType, SOFTBUS_IPC_ERR);
211 READ_PARCEL_WITH_RET(data, Int32, channel->osType, SOFTBUS_IPC_ERR);
212 READ_PARCEL_WITH_RET(data, Bool, channel->isSupportTlv, SOFTBUS_IPC_ERR);
213 return SOFTBUS_OK;
214 }
215
OnChannelOpenedInner(MessageParcel & data,MessageParcel & reply)216 int32_t SoftBusClientStub::OnChannelOpenedInner(MessageParcel &data, MessageParcel &reply)
217 {
218 const char *sessionName = data.ReadCString();
219 COMM_CHECK_AND_RETURN_RET_LOGE(sessionName != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read sessionName failed");
220
221 ChannelInfo channel = { 0 };
222 int32_t ret = MessageParcelRead(data, &channel);
223 if (ret != SOFTBUS_OK) {
224 (void)memset_s(&channel, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
225 COMM_LOGE(COMM_SDK, "read channel info failed");
226 return ret;
227 }
228
229 ret = OnChannelOpened(sessionName, &channel);
230 COMM_CHECK_AND_RETURN_RET_LOGE(reply.WriteInt32(ret), SOFTBUS_IPC_ERR, COMM_SDK, "write reply failed");
231 return SOFTBUS_OK;
232 }
233
OnChannelOpenFailedInner(MessageParcel & data,MessageParcel & reply)234 int32_t SoftBusClientStub::OnChannelOpenFailedInner(MessageParcel &data, MessageParcel &reply)
235 {
236 int32_t channelId;
237 COMM_CHECK_AND_RETURN_RET_LOGE(
238 data.ReadInt32(channelId), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelId failed");
239
240 int32_t channelType;
241 COMM_CHECK_AND_RETURN_RET_LOGE(
242 data.ReadInt32(channelType), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelType failed");
243
244 int32_t errCode;
245 COMM_CHECK_AND_RETURN_RET_LOGE(
246 data.ReadInt32(errCode), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read errCode failed");
247
248 int32_t ret = OnChannelOpenFailed(channelId, channelType, errCode);
249 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, COMM_SDK, "OnChannelOpenFailed fail! ret=%{public}d", ret);
250
251 return SOFTBUS_OK;
252 }
253
OnChannelLinkDownInner(MessageParcel & data,MessageParcel & reply)254 int32_t SoftBusClientStub::OnChannelLinkDownInner(MessageParcel &data, MessageParcel &reply)
255 {
256 const char *networkId = data.ReadCString();
257 COMM_CHECK_AND_RETURN_RET_LOGE(
258 networkId != nullptr, SOFTBUS_TRANS_PROXY_READCSTRING_FAILED, COMM_SDK, "read networkId failed!");
259
260 COMM_LOGD(COMM_SDK, "SDK OnChannelMsgReceived");
261 int32_t routeType;
262 COMM_CHECK_AND_RETURN_RET_LOGE(
263 data.ReadInt32(routeType), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read routeType failed");
264
265 int32_t retReply = OnChannelLinkDown(networkId, routeType);
266 if (retReply != SOFTBUS_OK) {
267 COMM_LOGE(COMM_SDK, "OnChannelLinkDown proc error!");
268 }
269 return SOFTBUS_OK;
270 }
271
OnChannelClosedInner(MessageParcel & data,MessageParcel & reply)272 int32_t SoftBusClientStub::OnChannelClosedInner(MessageParcel &data, MessageParcel &reply)
273 {
274 int32_t channelId;
275 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelId), SOFTBUS_IPC_ERR, COMM_SDK, "read channelId failed");
276
277 int32_t channelType;
278 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelType), SOFTBUS_IPC_ERR, COMM_SDK, "read channelType failed");
279
280 int32_t messageType;
281 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(messageType), SOFTBUS_IPC_ERR, COMM_SDK, "read messageType failed");
282
283 int32_t ret = OnChannelClosed(channelId, channelType, messageType);
284 COMM_CHECK_AND_RETURN_RET_LOGE(reply.WriteInt32(ret), SOFTBUS_IPC_ERR, COMM_SDK, "write reply failed");
285
286 return SOFTBUS_OK;
287 }
288
OnChannelMsgReceivedInner(MessageParcel & data,MessageParcel & reply)289 int32_t SoftBusClientStub::OnChannelMsgReceivedInner(MessageParcel &data, MessageParcel &reply)
290 {
291 int32_t channelId;
292 COMM_CHECK_AND_RETURN_RET_LOGE(
293 data.ReadInt32(channelId), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelId failed");
294
295 int32_t channelType;
296 COMM_CHECK_AND_RETURN_RET_LOGE(
297 data.ReadInt32(channelType), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelType failed");
298
299 uint32_t len;
300 COMM_CHECK_AND_RETURN_RET_LOGE(
301 data.ReadUint32(len), SOFTBUS_TRANS_PROXY_READUINT_FAILED, COMM_SDK, "read data len failed");
302
303 char *dataInfo = (char *)data.ReadRawData(len);
304 COMM_CHECK_AND_RETURN_RET_LOGE(
305 dataInfo != nullptr, SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, COMM_SDK, "read dataInfo failed!");
306
307 int32_t type;
308 COMM_CHECK_AND_RETURN_RET_LOGE(
309 data.ReadInt32(type), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read type failed");
310
311 int ret = OnChannelMsgReceived(channelId, channelType, dataInfo, len, type);
312 COMM_CHECK_AND_RETURN_RET_LOGE(
313 reply.WriteInt32(ret), SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, COMM_SDK, "write reply failed");
314
315 return SOFTBUS_OK;
316 }
317
OnChannelQosEventInner(MessageParcel & data,MessageParcel & reply)318 int32_t SoftBusClientStub::OnChannelQosEventInner(MessageParcel &data, MessageParcel &reply)
319 {
320 COMM_LOGI(COMM_EVENT, "OnChannelQosEventInner");
321 int32_t channelId;
322 COMM_CHECK_AND_RETURN_RET_LOGE(
323 data.ReadInt32(channelId), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelId failed");
324
325 int32_t channelType;
326 COMM_CHECK_AND_RETURN_RET_LOGE(
327 data.ReadInt32(channelType), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelType failed");
328
329 int32_t eventId;
330 COMM_CHECK_AND_RETURN_RET_LOGE(
331 data.ReadInt32(eventId), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read eventId failed");
332
333 int32_t tvCount;
334 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(tvCount) && tvCount > 0 && tvCount <= STREAM_TRAFFIC_STASTICS,
335 SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read tv failed! count=%{public}d", tvCount);
336
337 QosTv *tvList = (QosTv *)data.ReadRawData(sizeof(QosTv) * tvCount);
338 COMM_CHECK_AND_RETURN_RET_LOGE(
339 tvList != nullptr, SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, COMM_SDK, "read tv list failed!");
340
341 int ret = OnChannelQosEvent(channelId, channelType, eventId, tvCount, tvList);
342 COMM_CHECK_AND_RETURN_RET_LOGE(
343 reply.WriteInt32(ret), SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, COMM_SDK, "write reply failed");
344
345 return SOFTBUS_OK;
346 }
347
OnChannelOnQosInner(MessageParcel & data,MessageParcel & reply)348 int32_t SoftBusClientStub::OnChannelOnQosInner(MessageParcel &data, MessageParcel &reply)
349 {
350 COMM_LOGI(COMM_EVENT, "OnChannelOnQosInner");
351 int32_t channelId;
352 COMM_CHECK_AND_RETURN_RET_LOGE(
353 data.ReadInt32(channelId), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelId failed");
354
355 int32_t channelType;
356 COMM_CHECK_AND_RETURN_RET_LOGE(
357 data.ReadInt32(channelType), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelType failed");
358
359 int32_t event;
360 COMM_CHECK_AND_RETURN_RET_LOGE(
361 data.ReadInt32(event), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read event failed");
362
363 uint32_t count;
364 COMM_CHECK_AND_RETURN_RET_LOGE(
365 data.ReadUint32(count), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read count failed");
366 COMM_CHECK_AND_RETURN_RET_LOGE(count < QOS_TYPE_BUTT, SOFTBUS_INVALID_PARAM, COMM_SDK, "invalid count");
367
368 QosTV *qos = (QosTV *)data.ReadBuffer(sizeof(QosTV) * count);
369 COMM_CHECK_AND_RETURN_RET_LOGE(
370 qos != nullptr, SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, COMM_SDK, "read qos failed!");
371
372 int32_t ret = OnClientChannelOnQos(channelId, channelType, (QoSEvent)event, qos, count);
373 if (ret != SOFTBUS_OK) {
374 COMM_LOGE(COMM_SDK, "OnClientChannelOnQos failed, ret=%{public}d", ret);
375 }
376 return SOFTBUS_OK;
377 }
378
SetChannelInfoInner(MessageParcel & data,MessageParcel & reply)379 int32_t SoftBusClientStub::SetChannelInfoInner(MessageParcel &data, MessageParcel &reply)
380 {
381 const char *sessionName = data.ReadCString();
382 COMM_CHECK_AND_RETURN_RET_LOGE(sessionName != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read sessionName failed");
383
384 int32_t sessionId;
385 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(sessionId), SOFTBUS_IPC_ERR, COMM_SDK, "read sessionId failed");
386
387 int32_t channelId;
388 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelId), SOFTBUS_IPC_ERR, COMM_SDK, "read channelId failed");
389
390 int32_t channelType;
391 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelType), SOFTBUS_IPC_ERR, COMM_SDK, "read channelType failed");
392
393 int ret = SetChannelInfo(sessionName, sessionId, channelId, channelType);
394 COMM_CHECK_AND_RETURN_RET_LOGE(
395 reply.WriteInt32(ret), SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, COMM_SDK, "write reply failed");
396
397 return SOFTBUS_OK;
398 }
399
OnJoinLNNResultInner(MessageParcel & data,MessageParcel & reply)400 int32_t SoftBusClientStub::OnJoinLNNResultInner(MessageParcel &data, MessageParcel &reply)
401 {
402 uint32_t addrTypeLen;
403 if (!data.ReadUint32(addrTypeLen) || addrTypeLen != sizeof(ConnectionAddr)) {
404 COMM_LOGE(COMM_SDK, "OnJoinLNNResultInner read addr type failed! length=%{public}d", addrTypeLen);
405 return SOFTBUS_TRANS_PROXY_READUINT_FAILED;
406 }
407 void *addr = (void *)data.ReadRawData(addrTypeLen);
408 if (addr == nullptr) {
409 COMM_LOGE(COMM_SDK, "OnJoinLNNResultInner read addr failed!");
410 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
411 }
412 int32_t retCode;
413 if (!data.ReadInt32(retCode)) {
414 COMM_LOGE(COMM_SDK, "OnJoinLNNResultInner read retCode failed!");
415 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
416 }
417 const char *networkId = nullptr;
418 if (retCode == 0) {
419 networkId = data.ReadCString();
420 if (networkId == nullptr) {
421 COMM_LOGE(COMM_SDK, "OnJoinLNNResultInner read networkId failed!");
422 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
423 }
424 }
425 int32_t retReply = OnJoinLNNResult(addr, addrTypeLen, networkId, retCode);
426 if (retReply != SOFTBUS_OK) {
427 COMM_LOGE(COMM_SDK, "OnJoinLNNResultInner notify join result failed!");
428 }
429 return SOFTBUS_OK;
430 }
431
OnLeaveLNNResultInner(MessageParcel & data,MessageParcel & reply)432 int32_t SoftBusClientStub::OnLeaveLNNResultInner(MessageParcel &data, MessageParcel &reply)
433 {
434 const char *networkId = data.ReadCString();
435 if (networkId == nullptr) {
436 COMM_LOGE(COMM_SDK, "OnLeaveLNNResultInner read networkId failed!");
437 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
438 }
439 int32_t retCode;
440 if (!data.ReadInt32(retCode)) {
441 COMM_LOGE(COMM_SDK, "OnLeaveLNNResultInner read retCode failed!");
442 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
443 }
444 int32_t retReply = OnLeaveLNNResult(networkId, retCode);
445 if (retReply != SOFTBUS_OK) {
446 COMM_LOGE(COMM_SDK, "OnLeaveLNNResultInner notify leave result failed!");
447 }
448 return SOFTBUS_OK;
449 }
450
OnNodeOnlineStateChangedInner(MessageParcel & data,MessageParcel & reply)451 int32_t SoftBusClientStub::OnNodeOnlineStateChangedInner(MessageParcel &data, MessageParcel &reply)
452 {
453 const char *pkgName = data.ReadCString();
454 if (pkgName == nullptr || strlen(pkgName) == 0) {
455 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
456 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
457 }
458 bool isOnline = false;
459 if (!data.ReadBool(isOnline)) {
460 COMM_LOGE(COMM_SDK, "OnNodeOnlineStateChangedInner read online state failed!");
461 return SOFTBUS_TRANS_PROXY_READBOOL_FAILED;
462 }
463 uint32_t infoTypeLen;
464 if (!data.ReadUint32(infoTypeLen) || infoTypeLen != sizeof(NodeBasicInfo)) {
465 COMM_LOGE(COMM_SDK, "OnNodeOnlineStateChangedInner read info type failed! length=%{public}d", infoTypeLen);
466 return SOFTBUS_TRANS_PROXY_READUINT_FAILED;
467 }
468 void *info = (void *)data.ReadRawData(infoTypeLen);
469 if (info == nullptr) {
470 COMM_LOGE(COMM_SDK, "OnNodeOnlineStateChangedInner read basic info failed!");
471 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
472 }
473 int32_t retReply = OnNodeOnlineStateChanged(pkgName, isOnline, info, infoTypeLen);
474 COMM_LOGI(COMM_SDK, "notify complete, pkgName=%{public}s, isOnline=%{public}d", pkgName, isOnline);
475 if (!reply.WriteInt32(retReply)) {
476 COMM_LOGE(COMM_SDK, "OnNodeOnlineStateChangedInner write reply failed!");
477 return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
478 }
479 return SOFTBUS_OK;
480 }
481
OnNodeBasicInfoChangedInner(MessageParcel & data,MessageParcel & reply)482 int32_t SoftBusClientStub::OnNodeBasicInfoChangedInner(MessageParcel &data, MessageParcel &reply)
483 {
484 const char *pkgName = data.ReadCString();
485 if (pkgName == nullptr || strlen(pkgName) == 0) {
486 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
487 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
488 }
489 int32_t type;
490 if (!data.ReadInt32(type)) {
491 COMM_LOGE(COMM_SDK, "OnNodeBasicInfoChangedInner read type failed!");
492 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
493 }
494 COMM_LOGD(COMM_SDK, "OnNodeBasicInfoChangedInner type. type=%{public}d", type);
495 uint32_t infoTypeLen;
496 if (!data.ReadUint32(infoTypeLen) || infoTypeLen != sizeof(NodeBasicInfo)) {
497 COMM_LOGE(COMM_SDK, "OnNodeBasicInfoChangedInner read failed! infoTypeLen=%{public}d", infoTypeLen);
498 return SOFTBUS_TRANS_PROXY_READUINT_FAILED;
499 }
500 void *info = (void *)data.ReadRawData(infoTypeLen);
501 if (info == nullptr) {
502 COMM_LOGE(COMM_SDK, "OnNodeBasicInfoChangedInner read basic info failed!");
503 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
504 }
505 int32_t retReply = OnNodeBasicInfoChanged(pkgName, info, infoTypeLen, type);
506 if (!reply.WriteInt32(retReply)) {
507 COMM_LOGE(COMM_SDK, "OnNodeBasicInfoChangedInner write reply failed!");
508 return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
509 }
510 return SOFTBUS_OK;
511 }
512
OnNodeStatusChangedInner(MessageParcel & data,MessageParcel & reply)513 int32_t SoftBusClientStub::OnNodeStatusChangedInner(MessageParcel &data, MessageParcel &reply)
514 {
515 const char *pkgName = data.ReadCString();
516 if (pkgName == nullptr || strlen(pkgName) == 0) {
517 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
518 return SOFTBUS_INVALID_PARAM;
519 }
520 int32_t type;
521 if (!data.ReadInt32(type)) {
522 COMM_LOGE(COMM_SDK, "OnNodeStatusChangedInner read type failed!");
523 return SOFTBUS_NETWORK_READINT32_FAILED;
524 }
525 COMM_LOGD(COMM_SDK, "OnNodeStatusChangedInner type=%{public}d", type);
526 uint32_t infoTypeLen;
527 if (!data.ReadUint32(infoTypeLen) || infoTypeLen != sizeof(NodeStatus)) {
528 COMM_LOGE(COMM_SDK, "OnNodeStatusChangedInner read failed! infoTypeLen=%{public}d", infoTypeLen);
529 return SOFTBUS_NETWORK_READINT32_FAILED;
530 }
531 void *info = (void *)data.ReadRawData(infoTypeLen);
532 if (info == nullptr) {
533 COMM_LOGE(COMM_SDK, "OnNodeStatusChangedInner read node status failed!");
534 return SOFTBUS_NETWORK_READRAWDATA_FAILED;
535 }
536 int32_t retReply = OnNodeStatusChanged(pkgName, info, infoTypeLen, type);
537 if (!reply.WriteInt32(retReply)) {
538 COMM_LOGE(COMM_SDK, "OnNodeStatusChangedInner write reply failed!");
539 return SOFTBUS_NETWORK_WRITEINT32_FAILED;
540 }
541 return SOFTBUS_OK;
542 }
543
OnLocalNetworkIdChangedInner(MessageParcel & data,MessageParcel & reply)544 int32_t SoftBusClientStub::OnLocalNetworkIdChangedInner(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 int32_t retReply = OnLocalNetworkIdChanged(pkgName);
552 if (!reply.WriteInt32(retReply)) {
553 COMM_LOGE(COMM_SDK, "OnLocalNetworkIdChangedInner write reply failed!");
554 return SOFTBUS_IPC_ERR;
555 }
556 return SOFTBUS_OK;
557 }
558
OnNodeDeviceTrustedChangeInner(MessageParcel & data,MessageParcel & reply)559 int32_t SoftBusClientStub::OnNodeDeviceTrustedChangeInner(MessageParcel &data, MessageParcel &reply)
560 {
561 const char *pkgName = data.ReadCString();
562 if (pkgName == nullptr || strlen(pkgName) == 0) {
563 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
564 return SOFTBUS_INVALID_PARAM;
565 }
566 int32_t type = 0;
567 if (!data.ReadInt32(type)) {
568 COMM_LOGE(COMM_SDK, "read type failed!");
569 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
570 }
571 const char *msg = data.ReadCString();
572 if (msg == nullptr) {
573 COMM_LOGE(COMM_SDK, "read msg failed!");
574 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
575 }
576 uint32_t msgLen = 0;
577 if (!data.ReadUint32(msgLen)) {
578 COMM_LOGE(COMM_SDK, "read failed! msgLen=%{public}u", msgLen);
579 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
580 }
581 int32_t retReply = OnNodeDeviceTrustedChange(pkgName, type, msg, msgLen);
582 if (!reply.WriteInt32(retReply)) {
583 COMM_LOGE(COMM_SDK, "write reply failed!");
584 return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
585 }
586 return SOFTBUS_OK;
587 }
588
OnHichainProofExceptionInner(MessageParcel & data,MessageParcel & reply)589 int32_t SoftBusClientStub::OnHichainProofExceptionInner(MessageParcel &data, MessageParcel &reply)
590 {
591 const char *pkgName = data.ReadCString();
592 if (pkgName == nullptr || strlen(pkgName) == 0) {
593 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
594 return SOFTBUS_INVALID_PARAM;
595 }
596 uint32_t proofLen = 0;
597 if (!data.ReadUint32(proofLen)) {
598 COMM_LOGE(COMM_SDK, "read failed! proofLen=%{public}u", proofLen);
599 return SOFTBUS_NETWORK_PROXY_READINT_FAILED;
600 }
601 char *proofInfo = nullptr;
602 if (proofLen != 0) {
603 proofInfo = (char *)data.ReadRawData(proofLen);
604 if (proofInfo == nullptr) {
605 COMM_LOGE(COMM_SDK, "read proofInfo failed!");
606 return SOFTBUS_NETWORK_READRAWDATA_FAILED;
607 }
608 }
609 uint16_t deviceTypeId = 0;
610 if (!data.ReadUint16(deviceTypeId)) {
611 COMM_LOGE(COMM_SDK, "read failed! deviceTypeId=%{public}hu", deviceTypeId);
612 return SOFTBUS_NETWORK_PROXY_READINT_FAILED;
613 }
614 int32_t errCode = 0;
615 if (!data.ReadInt32(errCode)) {
616 COMM_LOGE(COMM_SDK, "read failed! errCode=%{public}d", errCode);
617 return SOFTBUS_NETWORK_PROXY_READINT_FAILED;
618 }
619 int32_t retReply = OnHichainProofException(pkgName, proofInfo, proofLen, deviceTypeId, errCode);
620 if (!reply.WriteInt32(retReply)) {
621 COMM_LOGE(COMM_SDK, "OnHichainProofException write reply failed!");
622 return SOFTBUS_NETWORK_WRITEINT32_FAILED;
623 }
624 return SOFTBUS_OK;
625 }
626
OnTimeSyncResultInner(MessageParcel & data,MessageParcel & reply)627 int32_t SoftBusClientStub::OnTimeSyncResultInner(MessageParcel &data, MessageParcel &reply)
628 {
629 uint32_t infoTypeLen;
630 if (!data.ReadUint32(infoTypeLen) || infoTypeLen != sizeof(TimeSyncResultInfo)) {
631 COMM_LOGE(COMM_SDK, "OnTimeSyncResultInner read info failed! length=%{public}d", infoTypeLen);
632 return SOFTBUS_TRANS_PROXY_READUINT_FAILED;
633 }
634 void *info = (void *)data.ReadRawData(infoTypeLen);
635 if (info == nullptr) {
636 COMM_LOGE(COMM_SDK, "OnTimeSyncResultInner read info failed!");
637 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
638 }
639 int32_t retCode;
640 if (!data.ReadInt32(retCode)) {
641 COMM_LOGE(COMM_SDK, "OnTimeSyncResultInner read retCode failed!");
642 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
643 }
644
645 int32_t retReply = OnTimeSyncResult(info, infoTypeLen, retCode);
646 if (!reply.WriteInt32(retReply)) {
647 COMM_LOGE(COMM_SDK, "OnTimeSyncResultInner write reply failed!");
648 return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
649 }
650 return SOFTBUS_OK;
651 }
652
OnPublishLNNResultInner(MessageParcel & data,MessageParcel & reply)653 int32_t SoftBusClientStub::OnPublishLNNResultInner(MessageParcel &data, MessageParcel &reply)
654 {
655 int32_t publishId;
656 if (!data.ReadInt32(publishId)) {
657 COMM_LOGE(COMM_SDK, "OnPublishLNNResultInner read publishId failed!");
658 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
659 }
660 int32_t reason;
661 if (!data.ReadInt32(reason)) {
662 COMM_LOGE(COMM_SDK, "OnPublishLNNResultInner read reason failed!");
663 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
664 }
665
666 OnPublishLNNResult(publishId, reason);
667 return SOFTBUS_OK;
668 }
669
OnRefreshLNNResultInner(MessageParcel & data,MessageParcel & reply)670 int32_t SoftBusClientStub::OnRefreshLNNResultInner(MessageParcel &data, MessageParcel &reply)
671 {
672 int32_t refreshId;
673 if (!data.ReadInt32(refreshId)) {
674 COMM_LOGE(COMM_SDK, "OnRefreshLNNResultInner read publishId failed!");
675 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
676 }
677 int32_t reason;
678 if (!data.ReadInt32(reason)) {
679 COMM_LOGE(COMM_SDK, "OnRefreshLNNResultInner read reason failed!");
680 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
681 }
682
683 OnRefreshLNNResult(refreshId, reason);
684 return SOFTBUS_OK;
685 }
686
OnRefreshDeviceFoundInner(MessageParcel & data,MessageParcel & reply)687 int32_t SoftBusClientStub::OnRefreshDeviceFoundInner(MessageParcel &data, MessageParcel &reply)
688 {
689 uint32_t deviceLen;
690 if (!data.ReadUint32(deviceLen) || deviceLen != sizeof(DeviceInfo)) {
691 COMM_LOGE(COMM_SDK, "OnRefreshDeviceFoundInner read info failed! length=%{public}d", deviceLen);
692 return SOFTBUS_TRANS_PROXY_READUINT_FAILED;
693 }
694 void *device = (void *)data.ReadRawData(deviceLen);
695 if (device == nullptr) {
696 COMM_LOGE(COMM_SDK, "OnRefreshDeviceFoundInner read info failed!");
697 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
698 }
699 OnRefreshDeviceFound(device, deviceLen);
700 return SOFTBUS_OK;
701 }
702
OnDataLevelChangedInner(MessageParcel & data,MessageParcel & reply)703 int32_t SoftBusClientStub::OnDataLevelChangedInner(MessageParcel &data, MessageParcel &reply)
704 {
705 const char *networkId = data.ReadCString();
706 if (networkId == nullptr || strlen(networkId) == 0) {
707 COMM_LOGE(COMM_SDK, "Invalid network, or length is zero");
708 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
709 }
710
711 DataLevelInfo *info = (DataLevelInfo *)data.ReadRawData(sizeof(DataLevelInfo));
712 if (info == nullptr) {
713 COMM_LOGE(COMM_SDK, "OnDataLevelChangedInner read data level change info failed");
714 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
715 }
716 OnDataLevelChanged(networkId, info);
717 return SOFTBUS_OK;
718 }
719
OnBleRangeDoneInner(MessageParcel & data,MessageParcel & reply)720 int32_t SoftBusClientStub::OnBleRangeDoneInner(MessageParcel &data, MessageParcel &reply)
721 {
722 BleRangeInnerInfo *info = (BleRangeInnerInfo *)data.ReadRawData(sizeof(BleRangeInnerInfo));
723 if (info == nullptr) {
724 COMM_LOGE(COMM_SDK, "read ble range info failed");
725 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
726 }
727 char *anonyNetworkId = nullptr;
728 Anonymize(info->networkId, &anonyNetworkId);
729 COMM_LOGI(COMM_SDK,
730 "range=%{public}d, subrange=%{public}d, distance=%{public}f, confidence=%{public}lf, networkId=%{public}s",
731 info->range, info->subRange, info->distance, info->confidence, AnonymizeWrapper(anonyNetworkId));
732 AnonymizeFree(anonyNetworkId);
733 OnBleRangeDone(info);
734 return SOFTBUS_OK;
735 }
736
OnChannelBind(int32_t channelId,int32_t channelType)737 int32_t SoftBusClientStub::OnChannelBind(int32_t channelId, int32_t channelType)
738 {
739 return TransOnChannelBind(channelId, channelType);
740 }
741
OnChannelBindInner(MessageParcel & data,MessageParcel & reply)742 int32_t SoftBusClientStub::OnChannelBindInner(MessageParcel &data, MessageParcel &reply)
743 {
744 int32_t channelId;
745 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelId), SOFTBUS_IPC_ERR, COMM_SDK, "read channelId failed");
746
747 int32_t channelType;
748 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelType), SOFTBUS_IPC_ERR, COMM_SDK, "read channelType failed");
749
750 int32_t ret = OnChannelBind(channelId, channelType);
751 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, COMM_SDK,
752 "OnChannelBind failed! ret=%{public}d, channelId=%{public}d, channelType=%{public}d",
753 ret, channelId, channelType);
754
755 return SOFTBUS_OK;
756 }
757
MessageParcelReadCollabInfo(MessageParcel & data,CollabInfo & info)758 static int32_t MessageParcelReadCollabInfo(MessageParcel &data, CollabInfo &info)
759 {
760 const char *accountId = data.ReadCString();
761 if (accountId == nullptr) {
762 COMM_LOGE(COMM_SDK, "read accountId failed");
763 } else {
764 if (strcpy_s(info.accountId, sizeof(info.accountId), accountId) != EOK) {
765 COMM_LOGE(COMM_SDK, "strcpy_s failed to copy accountId");
766 }
767 }
768 READ_PARCEL_WITH_RET(data, Uint64, info.tokenId, SOFTBUS_IPC_ERR);
769 READ_PARCEL_WITH_RET(data, Int32, info.userId, SOFTBUS_IPC_ERR);
770 READ_PARCEL_WITH_RET(data, Int32, info.pid, SOFTBUS_IPC_ERR);
771 const char *deviceId = data.ReadCString();
772 COMM_CHECK_AND_RETURN_RET_LOGE(deviceId != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read deviceId failed");
773 if (strcpy_s(info.deviceId, sizeof(info.deviceId), deviceId) != EOK) {
774 COMM_LOGE(COMM_SDK, "strcpy_s failed to copy deviceId");
775 }
776 return SOFTBUS_OK;
777 }
778
OnCheckCollabRelation(const CollabInfo * sourceInfo,bool isSinkSide,const CollabInfo * sinkInfo,int32_t channelId,int32_t channelType)779 int32_t SoftBusClientStub::OnCheckCollabRelation(
780 const CollabInfo *sourceInfo, bool isSinkSide, const CollabInfo *sinkInfo, int32_t channelId, int32_t channelType)
781 {
782 if (sourceInfo == nullptr || sinkInfo == nullptr) {
783 COMM_LOGE(COMM_SDK, "invalid param.");
784 return SOFTBUS_INVALID_PARAM;
785 }
786 return TransOnCheckCollabRelation(sourceInfo, isSinkSide, sinkInfo, channelId, channelType);
787 }
788
OnCheckCollabRelationInner(MessageParcel & data,MessageParcel & reply)789 int32_t SoftBusClientStub::OnCheckCollabRelationInner(MessageParcel &data, MessageParcel &reply)
790 {
791 CollabInfo sourceInfo;
792 CollabInfo sinkInfo;
793 bool isSinkSide = false;
794 int32_t channelId = -1;
795 int32_t channelType = -1;
796 READ_PARCEL_WITH_RET(data, Bool, isSinkSide, SOFTBUS_IPC_ERR);
797 int32_t ret = MessageParcelReadCollabInfo(data, sourceInfo);
798 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, COMM_SDK, "read source info failed");
799 ret = MessageParcelReadCollabInfo(data, sinkInfo);
800 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, COMM_SDK, "read sink info failed");
801 if (isSinkSide) {
802 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelId), SOFTBUS_IPC_ERR, COMM_SDK, "read channelId failed");
803 COMM_CHECK_AND_RETURN_RET_LOGE(
804 data.ReadInt32(channelType), SOFTBUS_IPC_ERR, COMM_SDK, "read channelType failed");
805 }
806 ret = OnCheckCollabRelation(&sourceInfo, isSinkSide, &sinkInfo, channelId, channelType);
807 COMM_CHECK_AND_RETURN_RET_LOGE(
808 ret == SOFTBUS_OK, ret, COMM_SDK, "CheckCollabRelation failed! ret=%{public}d.", ret);
809 return SOFTBUS_OK;
810 }
811
OnJoinLNNResult(void * addr,uint32_t addrTypeLen,const char * networkId,int retCode)812 int32_t SoftBusClientStub::OnJoinLNNResult(void *addr, uint32_t addrTypeLen, const char *networkId, int retCode)
813 {
814 (void)addrTypeLen;
815 return LnnOnJoinResult(addr, networkId, retCode);
816 }
817
OnLeaveLNNResult(const char * networkId,int retCode)818 int32_t SoftBusClientStub::OnLeaveLNNResult(const char *networkId, int retCode)
819 {
820 return LnnOnLeaveResult(networkId, retCode);
821 }
822
OnNodeOnlineStateChanged(const char * pkgName,bool isOnline,void * info,uint32_t infoTypeLen)823 int32_t SoftBusClientStub::OnNodeOnlineStateChanged(const char *pkgName, bool isOnline,
824 void *info, uint32_t infoTypeLen)
825 {
826 (void)infoTypeLen;
827 return LnnOnNodeOnlineStateChanged(pkgName, isOnline, info);
828 }
829
OnNodeBasicInfoChanged(const char * pkgName,void * info,uint32_t infoTypeLen,int32_t type)830 int32_t SoftBusClientStub::OnNodeBasicInfoChanged(const char *pkgName, void *info, uint32_t infoTypeLen, int32_t type)
831 {
832 (void)infoTypeLen;
833 return LnnOnNodeBasicInfoChanged(pkgName, info, type);
834 }
835
OnNodeStatusChanged(const char * pkgName,void * info,uint32_t infoTypeLen,int32_t type)836 int32_t SoftBusClientStub::OnNodeStatusChanged(const char *pkgName, void *info, uint32_t infoTypeLen, int32_t type)
837 {
838 (void)infoTypeLen;
839 return LnnOnNodeStatusChanged(pkgName, info, type);
840 }
841
OnLocalNetworkIdChanged(const char * pkgName)842 int32_t SoftBusClientStub::OnLocalNetworkIdChanged(const char *pkgName)
843 {
844 return LnnOnLocalNetworkIdChanged(pkgName);
845 }
846
OnNodeDeviceTrustedChange(const char * pkgName,int32_t type,const char * msg,uint32_t msgLen)847 int32_t SoftBusClientStub::OnNodeDeviceTrustedChange(const char *pkgName, int32_t type, const char *msg,
848 uint32_t msgLen)
849 {
850 return LnnOnNodeDeviceTrustedChange(pkgName, type, msg, msgLen);
851 }
852
OnHichainProofException(const char * pkgName,const char * proofInfo,uint32_t proofLen,uint16_t deviceTypeId,int32_t errCode)853 int32_t SoftBusClientStub::OnHichainProofException(
854 const char *pkgName, const char *proofInfo, uint32_t proofLen, uint16_t deviceTypeId, int32_t errCode)
855 {
856 return LnnOnHichainProofException(pkgName, proofInfo, proofLen, deviceTypeId, errCode);
857 }
858
OnTimeSyncResult(const void * info,uint32_t infoTypeLen,int32_t retCode)859 int32_t SoftBusClientStub::OnTimeSyncResult(const void *info, uint32_t infoTypeLen, int32_t retCode)
860 {
861 (void)infoTypeLen;
862 return LnnOnTimeSyncResult(info, retCode);
863 }
864
OnPublishLNNResult(int32_t publishId,int32_t reason)865 void SoftBusClientStub::OnPublishLNNResult(int32_t publishId, int32_t reason)
866 {
867 LnnOnPublishLNNResult(publishId, reason);
868 }
869
OnRefreshLNNResult(int32_t refreshId,int32_t reason)870 void SoftBusClientStub::OnRefreshLNNResult(int32_t refreshId, int32_t reason)
871 {
872 LnnOnRefreshLNNResult(refreshId, reason);
873 }
874
OnRefreshDeviceFound(const void * device,uint32_t deviceLen)875 void SoftBusClientStub::OnRefreshDeviceFound(const void *device, uint32_t deviceLen)
876 {
877 (void)deviceLen;
878 LnnOnRefreshDeviceFound(device);
879 }
880
OnDataLevelChanged(const char * networkId,const DataLevelInfo * dataLevelInfo)881 void SoftBusClientStub::OnDataLevelChanged(const char *networkId, const DataLevelInfo *dataLevelInfo)
882 {
883 LnnOnDataLevelChanged(networkId, dataLevelInfo);
884 }
885
OnBleRangeDone(const BleRangeInnerInfo * rangeInfo)886 void SoftBusClientStub::OnBleRangeDone(const BleRangeInnerInfo *rangeInfo)
887 {
888 LnnOnBleRangeDone(rangeInfo);
889 }
890
OnClientChannelOnQos(int32_t channelId,int32_t channelType,QoSEvent event,const QosTV * qos,uint32_t count)891 int32_t SoftBusClientStub::OnClientChannelOnQos(
892 int32_t channelId, int32_t channelType, QoSEvent event, const QosTV *qos, uint32_t count)
893 {
894 if (event < QOS_SATISFIED || event > QOS_NOT_SATISFIED) {
895 COMM_LOGE(COMM_SDK, "OnChannelOnQos invalid event=%{public}d", event);
896 return SOFTBUS_INVALID_PARAM;
897 }
898 if (qos == nullptr || count == 0) {
899 COMM_LOGE(COMM_SDK, "OnChannelOnQos invalid qos or count");
900 return SOFTBUS_INVALID_PARAM;
901 }
902 return TransOnChannelOnQos(channelId, channelType, event, qos, count);
903 }
904 } // namespace OHOS
905