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 "br_proxy.h"
20 #include "client_bus_center_manager.h"
21 #include "general_client_connection.h"
22 #include "client_trans_channel_callback.h"
23 #include "client_trans_socket_manager.h"
24 #include "client_trans_udp_manager.h"
25 #include "securec.h"
26 #include "session_set_timer.h"
27 #include "softbus_access_token_adapter.h"
28 #include "softbus_server_ipc_interface_code.h"
29
30 namespace OHOS {
31 static constexpr uint32_t DFX_TIMERS_S = 15;
32
SoftBusClientStub()33 SoftBusClientStub::SoftBusClientStub()
34 {
35 memberFuncMap_[CLIENT_ON_CHANNEL_OPENED] = &SoftBusClientStub::OnChannelOpenedInner;
36 memberFuncMap_[CLIENT_ON_CHANNEL_OPENFAILED] = &SoftBusClientStub::OnChannelOpenFailedInner;
37 memberFuncMap_[CLIENT_ON_CHANNEL_LINKDOWN] = &SoftBusClientStub::OnChannelLinkDownInner;
38 memberFuncMap_[CLIENT_ON_CHANNEL_CLOSED] = &SoftBusClientStub::OnChannelClosedInner;
39 memberFuncMap_[CLIENT_ON_CHANNEL_MSGRECEIVED] = &SoftBusClientStub::OnChannelMsgReceivedInner;
40 memberFuncMap_[CLIENT_ON_CHANNEL_QOSEVENT] = &SoftBusClientStub::OnChannelQosEventInner;
41 memberFuncMap_[CLIENT_ON_JOIN_RESULT] = &SoftBusClientStub::OnJoinLNNResultInner;
42 memberFuncMap_[CLIENT_ON_LEAVE_RESULT] = &SoftBusClientStub::OnLeaveLNNResultInner;
43 memberFuncMap_[CLIENT_ON_NODE_ONLINE_STATE_CHANGED] = &SoftBusClientStub::OnNodeOnlineStateChangedInner;
44 memberFuncMap_[CLIENT_ON_NODE_BASIC_INFO_CHANGED] = &SoftBusClientStub::OnNodeBasicInfoChangedInner;
45 memberFuncMap_[CLIENT_ON_NODE_STATUS_CHANGED] = &SoftBusClientStub::OnNodeStatusChangedInner;
46 memberFuncMap_[CLIENT_ON_LOCAL_NETWORK_ID_CHANGED] = &SoftBusClientStub::OnLocalNetworkIdChangedInner;
47 memberFuncMap_[CLIENT_ON_NODE_DEVICE_TRUST_CHANGED] = &SoftBusClientStub::OnNodeDeviceTrustedChangeInner;
48 memberFuncMap_[CLIENT_ON_HICHAIN_PROOF_EXCEPTION] = &SoftBusClientStub::OnHichainProofExceptionInner;
49 memberFuncMap_[CLIENT_ON_TIME_SYNC_RESULT] = &SoftBusClientStub::OnTimeSyncResultInner;
50 memberFuncMap_[CLIENT_ON_PUBLISH_LNN_RESULT] = &SoftBusClientStub::OnPublishLNNResultInner;
51 memberFuncMap_[CLIENT_ON_REFRESH_LNN_RESULT] = &SoftBusClientStub::OnRefreshLNNResultInner;
52 memberFuncMap_[CLIENT_ON_REFRESH_DEVICE_FOUND] = &SoftBusClientStub::OnRefreshDeviceFoundInner;
53 memberFuncMap_[CLIENT_ON_PERMISSION_CHANGE] = &SoftBusClientStub::OnClientPermissonChangeInner;
54 memberFuncMap_[CLIENT_SET_CHANNEL_INFO] = &SoftBusClientStub::SetChannelInfoInner;
55 memberFuncMap_[CLIENT_ON_DATA_LEVEL_CHANGED] = &SoftBusClientStub::OnDataLevelChangedInner;
56 memberFuncMap_[CLIENT_ON_RANGE_RESULT] = &SoftBusClientStub::OnMsdpRangeResultInner;
57 memberFuncMap_[CLIENT_ON_TRANS_LIMIT_CHANGE] = &SoftBusClientStub::OnClientTransLimitChangeInner;
58 memberFuncMap_[CLIENT_ON_CHANNEL_BIND] = &SoftBusClientStub::OnChannelBindInner;
59 memberFuncMap_[CLIENT_CHANNEL_ON_QOS] = &SoftBusClientStub::OnChannelOnQosInner;
60 memberFuncMap_[CLIENT_CHECK_COLLAB_RELATION] = &SoftBusClientStub::OnCheckCollabRelationInner;
61 memberFuncMap_[CLIENT_GENERAL_CONNECTION_STATE_CHANGE] = &SoftBusClientStub::OnConnectionStateChangeInner;
62 memberFuncMap_[CLIENT_GENERAL_ACCEPT_CONNECT] = &SoftBusClientStub::OnAcceptConnectInner;
63 memberFuncMap_[CLIENT_GENERAL_DATA_RECEIVED] = &SoftBusClientStub::OnDataReceivedInner;
64 memberFuncMap_[CLIENT_ON_BR_PROXY_OPENED] = &SoftBusClientStub::OnBrProxyOpenedInner;
65 memberFuncMap_[CLIENT_ON_BR_PROXY_DATA_RECV] = &SoftBusClientStub::OnBrProxyDataRecvInner;
66 memberFuncMap_[CLIENT_ON_BR_PROXY_STATE_CHANGED] = &SoftBusClientStub::OnBrProxyStateChangedInner;
67 memberFuncMap_[CLIENT_ON_BR_PROXY_QUERY_PERMISSION] = &SoftBusClientStub::OnBrProxyQueryPermissionInner;
68 }
69
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)70 int32_t SoftBusClientStub::OnRemoteRequest(uint32_t code,
71 MessageParcel &data, MessageParcel &reply, MessageOption &option)
72 {
73 COMM_LOGD(COMM_SDK, "SoftBusClientStub::OnReceived, code=%{public}u", code);
74 if (data.ReadInterfaceToken() != GetDescriptor()) {
75 COMM_LOGE(COMM_SDK, "SoftBusClientStub: ReadInterfaceToken faild!");
76 return SOFTBUS_TRANS_PROXY_READTOKEN_FAILED;
77 }
78 auto itFunc = memberFuncMap_.find(code);
79 if (itFunc != memberFuncMap_.end()) {
80 auto memberFunc = itFunc->second;
81 if (memberFunc != nullptr) {
82 return (this->*memberFunc)(data, reply);
83 }
84 }
85 COMM_LOGI(COMM_SDK, "SoftBusClientStub: default case, need check.");
86 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
87 }
88
OnClientPermissonChangeInner(MessageParcel & data,MessageParcel & reply)89 int32_t SoftBusClientStub::OnClientPermissonChangeInner(MessageParcel &data, MessageParcel &reply)
90 {
91 int32_t state;
92 COMM_CHECK_AND_RETURN_RET_LOGE(
93 data.ReadInt32(state), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read state failed");
94
95 const char *pkgName = data.ReadCString();
96 COMM_CHECK_AND_RETURN_RET_LOGE(
97 pkgName != nullptr, SOFTBUS_TRANS_PROXY_READCSTRING_FAILED, COMM_SDK, "read pkgName failed");
98
99 PermissionStateChange(pkgName, state);
100 return SOFTBUS_OK;
101 }
102
OnClientTransLimitChangeInner(MessageParcel & data,MessageParcel & reply)103 int32_t SoftBusClientStub::OnClientTransLimitChangeInner(MessageParcel &data, MessageParcel &reply)
104 {
105 int32_t channelId;
106 COMM_CHECK_AND_RETURN_RET_LOGE(
107 data.ReadInt32(channelId), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, COMM_SDK, "read channelId failed");
108
109 uint8_t tos;
110 COMM_CHECK_AND_RETURN_RET_LOGE(
111 data.ReadUint8(tos), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, COMM_SDK, "read tos failed");
112
113 int32_t ret = OnClientTransLimitChange(channelId, tos);
114 COMM_CHECK_AND_RETURN_RET_LOGE(
115 reply.WriteInt32(ret), SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED, COMM_SDK, "write reply failed");
116
117 return SOFTBUS_OK;
118 }
119
OnClientTransLimitChange(int32_t channelId,uint8_t tos)120 int32_t SoftBusClientStub::OnClientTransLimitChange(int32_t channelId, uint8_t tos)
121 {
122 return TransLimitChange(channelId, tos);
123 }
124
OnChannelOpened(const char * sessionName,const ChannelInfo * info)125 int32_t SoftBusClientStub::OnChannelOpened(const char *sessionName, const ChannelInfo *info)
126 {
127 int32_t id = SetTimer("OnChannelOpened", DFX_TIMERS_S);
128 int32_t ret = TransOnChannelOpened(sessionName, info);
129 CancelTimer(id);
130 return ret;
131 }
132
OnChannelOpenFailed(int32_t channelId,int32_t channelType,int32_t errCode)133 int32_t SoftBusClientStub::OnChannelOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)
134 {
135 return TransOnChannelOpenFailed(channelId, channelType, errCode);
136 }
137
OnChannelLinkDown(const char * networkId,int32_t routeType)138 int32_t SoftBusClientStub::OnChannelLinkDown(const char *networkId, int32_t routeType)
139 {
140 return TransOnChannelLinkDown(networkId, routeType);
141 }
142
OnChannelClosed(int32_t channelId,int32_t channelType,int32_t messageType)143 int32_t SoftBusClientStub::OnChannelClosed(int32_t channelId, int32_t channelType, int32_t messageType)
144 {
145 return TransOnChannelClosed(channelId, channelType, messageType, SHUTDOWN_REASON_PEER);
146 }
147
OnChannelMsgReceived(int32_t channelId,int32_t channelType,const void * data,uint32_t len,int32_t type)148 int32_t SoftBusClientStub::OnChannelMsgReceived(int32_t channelId, int32_t channelType, const void *data,
149 uint32_t len, int32_t type)
150 {
151 return TransOnChannelMsgReceived(channelId, channelType, data, len, static_cast<SessionPktType>(type));
152 }
153
OnChannelQosEvent(int32_t channelId,int32_t channelType,int32_t eventId,int32_t tvCount,const QosTv * tvList)154 int32_t SoftBusClientStub::OnChannelQosEvent(int32_t channelId, int32_t channelType, int32_t eventId,
155 int32_t tvCount, const QosTv *tvList)
156 {
157 return TransOnChannelQosEvent(channelId, channelType, eventId, tvCount, tvList);
158 }
159
SetChannelInfo(const char * sessionName,int32_t sessionId,int32_t channelId,int32_t channelType)160 int32_t SoftBusClientStub::SetChannelInfo(
161 const char *sessionName, int32_t sessionId, int32_t channelId, int32_t channelType)
162 {
163 return TransSetChannelInfo(sessionName, sessionId, channelId, channelType);
164 }
165
MessageTcpParcelRead(MessageParcel & data,ChannelInfo * channel)166 static int32_t MessageTcpParcelRead(MessageParcel &data, ChannelInfo *channel)
167 {
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 READ_PARCEL_WITH_RET(data, Uint32, channel->fdProtocol, SOFTBUS_IPC_ERR);
173 channel->peerIp = (char *)data.ReadCString();
174 COMM_CHECK_AND_RETURN_RET_LOGE(channel->peerIp != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read peerIp failed");
175 READ_PARCEL_WITH_RET(data, Int32, channel->peerPort, SOFTBUS_IPC_ERR);
176 channel->pkgName = (char *)data.ReadCString();
177 COMM_CHECK_AND_RETURN_RET_LOGE(channel->pkgName != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read pkgName failed");
178 }
179 return SOFTBUS_OK;
180 }
181
MessageParcelReadEx(MessageParcel & data,ChannelInfo * channel)182 static int32_t MessageParcelReadEx(MessageParcel &data, ChannelInfo *channel)
183 {
184 READ_PARCEL_WITH_RET(data, Int32, channel->routeType, SOFTBUS_IPC_ERR);
185 READ_PARCEL_WITH_RET(data, Int32, channel->encrypt, SOFTBUS_IPC_ERR);
186 READ_PARCEL_WITH_RET(data, Int32, channel->algorithm, SOFTBUS_IPC_ERR);
187 READ_PARCEL_WITH_RET(data, Int32, channel->crc, SOFTBUS_IPC_ERR);
188 READ_PARCEL_WITH_RET(data, Uint32, channel->dataConfig, SOFTBUS_IPC_ERR);
189 READ_PARCEL_WITH_RET(data, Int32, channel->linkType, SOFTBUS_IPC_ERR);
190 READ_PARCEL_WITH_RET(data, Int32, channel->osType, SOFTBUS_IPC_ERR);
191 READ_PARCEL_WITH_RET(data, Bool, channel->isSupportTlv, SOFTBUS_IPC_ERR);
192 channel->peerDeviceId = (char *)data.ReadCString();
193 COMM_CHECK_AND_RETURN_RET_LOGE(channel->peerDeviceId != nullptr,
194 SOFTBUS_IPC_ERR, COMM_SDK, "read peerDeviceId failed");
195 READ_PARCEL_WITH_RET(data, Bool, channel->isD2D, SOFTBUS_IPC_ERR);
196 if (channel->isD2D) {
197 READ_PARCEL_WITH_RET(data, Int32, channel->pagingId, SOFTBUS_IPC_ERR);
198 READ_PARCEL_WITH_RET(data, Uint32, channel->businessFlag, SOFTBUS_IPC_ERR);
199 READ_PARCEL_WITH_RET(data, Uint32, channel->deviceTypeId, SOFTBUS_IPC_ERR);
200 channel->pagingNonce = (char *)data.ReadRawData(PAGING_NONCE_LEN);
201 COMM_CHECK_AND_RETURN_RET_LOGE(channel->pagingNonce != nullptr, SOFTBUS_IPC_ERR,
202 COMM_SDK, "read pagingNonce failed");
203 channel->pagingSessionkey = (char *)data.ReadRawData(SHORT_SESSION_KEY_LENGTH);
204 COMM_CHECK_AND_RETURN_RET_LOGE(channel->pagingSessionkey != nullptr, SOFTBUS_IPC_ERR,
205 COMM_SDK, "read pagingSessionkey failed");
206 READ_PARCEL_WITH_RET(data, Uint32, channel->dataLen, SOFTBUS_IPC_ERR);
207 if (channel->dataLen > 0) {
208 channel->extraData = (char *)data.ReadRawData(channel->dataLen);
209 COMM_CHECK_AND_RETURN_RET_LOGE(channel->extraData != nullptr, SOFTBUS_IPC_ERR,
210 COMM_SDK, "read extraData failed");
211 }
212 if (channel->isServer) {
213 channel->pagingAccountId = (char *)data.ReadCString();
214 COMM_CHECK_AND_RETURN_RET_LOGE(channel->pagingAccountId != nullptr,
215 SOFTBUS_IPC_ERR, COMM_SDK, "read pagingAccountId failed");
216 }
217 } else {
218 READ_PARCEL_WITH_RET(data, Int32, channel->tokenType, SOFTBUS_IPC_ERR);
219 if (channel->tokenType > ACCESS_TOKEN_TYPE_HAP && channel->channelType != CHANNEL_TYPE_AUTH &&
220 channel->isServer) {
221 READ_PARCEL_WITH_RET(data, Int32, channel->peerUserId, SOFTBUS_IPC_ERR);
222 READ_PARCEL_WITH_RET(data, Uint64, channel->peerTokenId, SOFTBUS_IPC_ERR);
223 channel->peerExtraAccessInfo = (char *)data.ReadCString();
224 }
225 channel->sessionKey = (char *)data.ReadRawData(channel->keyLen);
226 COMM_CHECK_AND_RETURN_RET_LOGE(channel->sessionKey != nullptr, SOFTBUS_IPC_ERR,
227 COMM_SDK, "read rawData failed");
228 channel->groupId = (char *)data.ReadCString();
229 COMM_CHECK_AND_RETURN_RET_LOGE(channel->groupId != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read groupId failed");
230 }
231 return SOFTBUS_OK;
232 }
233
MessageParcelRead(MessageParcel & data,ChannelInfo * channel)234 static int32_t MessageParcelRead(MessageParcel &data, ChannelInfo *channel)
235 {
236 READ_PARCEL_WITH_RET(data, Int32, channel->sessionId, SOFTBUS_IPC_ERR);
237 READ_PARCEL_WITH_RET(data, Int32, channel->channelId, SOFTBUS_IPC_ERR);
238 READ_PARCEL_WITH_RET(data, Int32, channel->channelType, SOFTBUS_IPC_ERR);
239 READ_PARCEL_WITH_RET(data, Uint64, channel->laneId, SOFTBUS_IPC_ERR);
240 READ_PARCEL_WITH_RET(data, Int32, channel->connectType, SOFTBUS_IPC_ERR);
241 int32_t ret = MessageTcpParcelRead(data, channel);
242 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_IPC_ERR, COMM_SDK, "read tcp ip or fd failed");
243 READ_PARCEL_WITH_RET(data, Bool, channel->isServer, SOFTBUS_IPC_ERR);
244 READ_PARCEL_WITH_RET(data, Bool, channel->isEnabled, SOFTBUS_IPC_ERR);
245 READ_PARCEL_WITH_RET(data, Bool, channel->isEncrypt, SOFTBUS_IPC_ERR);
246 READ_PARCEL_WITH_RET(data, Int32, channel->peerUid, SOFTBUS_IPC_ERR);
247 READ_PARCEL_WITH_RET(data, Int32, channel->peerPid, SOFTBUS_IPC_ERR);
248 READ_PARCEL_WITH_RET(data, Uint32, channel->keyLen, SOFTBUS_IPC_ERR);
249 COMM_CHECK_AND_RETURN_RET_LOGE(channel->keyLen <= SESSION_KEY_LENGTH, SOFTBUS_IPC_ERR, COMM_SDK,
250 "channel->keyLen invalid");
251 channel->peerSessionName = (char *)data.ReadCString();
252 COMM_CHECK_AND_RETURN_RET_LOGE(
253 channel->peerSessionName != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read peerSessionName failed");
254 READ_PARCEL_WITH_RET(data, Int32, channel->businessType, SOFTBUS_IPC_ERR);
255 if (channel->channelType == CHANNEL_TYPE_UDP) {
256 channel->myIp = (char *)data.ReadCString();
257 COMM_CHECK_AND_RETURN_RET_LOGE(channel->myIp != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read myIp failed");
258 READ_PARCEL_WITH_RET(data, Int32, channel->streamType, SOFTBUS_IPC_ERR);
259 READ_PARCEL_WITH_RET(data, Bool, channel->isUdpFile, SOFTBUS_IPC_ERR);
260 if (!channel->isServer) {
261 READ_PARCEL_WITH_RET(data, Int32, channel->peerPort, SOFTBUS_IPC_ERR);
262 channel->peerIp = (char *)data.ReadCString();
263 COMM_CHECK_AND_RETURN_RET_LOGE(
264 channel->peerIp != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read channel.peerIp failed");
265 }
266 }
267 return MessageParcelReadEx(data, channel);
268 }
269
OnChannelOpenedInner(MessageParcel & data,MessageParcel & reply)270 int32_t SoftBusClientStub::OnChannelOpenedInner(MessageParcel &data, MessageParcel &reply)
271 {
272 const char *sessionName = data.ReadCString();
273 COMM_CHECK_AND_RETURN_RET_LOGE(sessionName != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read sessionName failed");
274
275 ChannelInfo channel = { 0 };
276 int32_t ret = MessageParcelRead(data, &channel);
277 if (ret != SOFTBUS_OK) {
278 (void)memset_s(&channel, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
279 COMM_LOGE(COMM_SDK, "read channel info failed");
280 return ret;
281 }
282
283 ret = OnChannelOpened(sessionName, &channel);
284 COMM_CHECK_AND_RETURN_RET_LOGE(reply.WriteInt32(ret), SOFTBUS_IPC_ERR, COMM_SDK, "write reply failed");
285 return SOFTBUS_OK;
286 }
287
OnChannelOpenFailedInner(MessageParcel & data,MessageParcel & reply)288 int32_t SoftBusClientStub::OnChannelOpenFailedInner(MessageParcel &data, MessageParcel &reply)
289 {
290 int32_t channelId;
291 COMM_CHECK_AND_RETURN_RET_LOGE(
292 data.ReadInt32(channelId), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelId failed");
293
294 int32_t channelType;
295 COMM_CHECK_AND_RETURN_RET_LOGE(
296 data.ReadInt32(channelType), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelType failed");
297
298 int32_t errCode;
299 COMM_CHECK_AND_RETURN_RET_LOGE(
300 data.ReadInt32(errCode), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read errCode failed");
301
302 int32_t ret = OnChannelOpenFailed(channelId, channelType, errCode);
303 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, COMM_SDK, "OnChannelOpenFailed fail! ret=%{public}d", ret);
304
305 return SOFTBUS_OK;
306 }
307
OnChannelLinkDownInner(MessageParcel & data,MessageParcel & reply)308 int32_t SoftBusClientStub::OnChannelLinkDownInner(MessageParcel &data, MessageParcel &reply)
309 {
310 const char *networkId = data.ReadCString();
311 COMM_CHECK_AND_RETURN_RET_LOGE(
312 networkId != nullptr, SOFTBUS_TRANS_PROXY_READCSTRING_FAILED, COMM_SDK, "read networkId failed!");
313
314 COMM_LOGD(COMM_SDK, "SDK OnChannelMsgReceived");
315 int32_t routeType;
316 COMM_CHECK_AND_RETURN_RET_LOGE(
317 data.ReadInt32(routeType), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read routeType failed");
318
319 int32_t retReply = OnChannelLinkDown(networkId, routeType);
320 if (retReply != SOFTBUS_OK) {
321 COMM_LOGE(COMM_SDK, "OnChannelLinkDown proc error!");
322 }
323 return SOFTBUS_OK;
324 }
325
OnChannelClosedInner(MessageParcel & data,MessageParcel & reply)326 int32_t SoftBusClientStub::OnChannelClosedInner(MessageParcel &data, MessageParcel &reply)
327 {
328 int32_t channelId;
329 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelId), SOFTBUS_IPC_ERR, COMM_SDK, "read channelId failed");
330
331 int32_t channelType;
332 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelType), SOFTBUS_IPC_ERR, COMM_SDK, "read channelType failed");
333
334 int32_t messageType;
335 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(messageType), SOFTBUS_IPC_ERR, COMM_SDK, "read messageType failed");
336
337 int32_t ret = OnChannelClosed(channelId, channelType, messageType);
338 COMM_CHECK_AND_RETURN_RET_LOGE(reply.WriteInt32(ret), SOFTBUS_IPC_ERR, COMM_SDK, "write reply failed");
339
340 return SOFTBUS_OK;
341 }
342
OnChannelMsgReceivedInner(MessageParcel & data,MessageParcel & reply)343 int32_t SoftBusClientStub::OnChannelMsgReceivedInner(MessageParcel &data, MessageParcel &reply)
344 {
345 int32_t channelId;
346 COMM_CHECK_AND_RETURN_RET_LOGE(
347 data.ReadInt32(channelId), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelId failed");
348
349 int32_t channelType;
350 COMM_CHECK_AND_RETURN_RET_LOGE(
351 data.ReadInt32(channelType), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelType failed");
352
353 uint32_t len;
354 COMM_CHECK_AND_RETURN_RET_LOGE(
355 data.ReadUint32(len), SOFTBUS_TRANS_PROXY_READUINT_FAILED, COMM_SDK, "read data len failed");
356
357 char *dataInfo = (char *)data.ReadRawData(len);
358 COMM_CHECK_AND_RETURN_RET_LOGE(
359 dataInfo != nullptr, SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, COMM_SDK, "read dataInfo failed!");
360
361 int32_t type;
362 COMM_CHECK_AND_RETURN_RET_LOGE(
363 data.ReadInt32(type), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read type failed");
364
365 int ret = OnChannelMsgReceived(channelId, channelType, dataInfo, len, type);
366 COMM_CHECK_AND_RETURN_RET_LOGE(
367 reply.WriteInt32(ret), SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, COMM_SDK, "write reply failed");
368
369 return SOFTBUS_OK;
370 }
371
OnChannelQosEventInner(MessageParcel & data,MessageParcel & reply)372 int32_t SoftBusClientStub::OnChannelQosEventInner(MessageParcel &data, MessageParcel &reply)
373 {
374 COMM_LOGI(COMM_EVENT, "OnChannelQosEventInner");
375 int32_t channelId;
376 COMM_CHECK_AND_RETURN_RET_LOGE(
377 data.ReadInt32(channelId), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelId failed");
378
379 int32_t channelType;
380 COMM_CHECK_AND_RETURN_RET_LOGE(
381 data.ReadInt32(channelType), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelType failed");
382
383 int32_t eventId;
384 COMM_CHECK_AND_RETURN_RET_LOGE(
385 data.ReadInt32(eventId), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read eventId failed");
386
387 int32_t tvCount;
388 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(tvCount) && tvCount > 0 && tvCount <= STREAM_TRAFFIC_STASTICS,
389 SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read tv failed! count=%{public}d", tvCount);
390
391 QosTv *tvList = (QosTv *)data.ReadRawData(sizeof(QosTv) * tvCount);
392 COMM_CHECK_AND_RETURN_RET_LOGE(
393 tvList != nullptr, SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, COMM_SDK, "read tv list failed!");
394
395 int ret = OnChannelQosEvent(channelId, channelType, eventId, tvCount, tvList);
396 COMM_CHECK_AND_RETURN_RET_LOGE(
397 reply.WriteInt32(ret), SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, COMM_SDK, "write reply failed");
398
399 return SOFTBUS_OK;
400 }
401
OnChannelOnQosInner(MessageParcel & data,MessageParcel & reply)402 int32_t SoftBusClientStub::OnChannelOnQosInner(MessageParcel &data, MessageParcel &reply)
403 {
404 COMM_LOGI(COMM_EVENT, "OnChannelOnQosInner");
405 int32_t channelId;
406 COMM_CHECK_AND_RETURN_RET_LOGE(
407 data.ReadInt32(channelId), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelId failed");
408
409 int32_t channelType;
410 COMM_CHECK_AND_RETURN_RET_LOGE(
411 data.ReadInt32(channelType), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelType failed");
412
413 int32_t event;
414 COMM_CHECK_AND_RETURN_RET_LOGE(
415 data.ReadInt32(event), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read event failed");
416
417 uint32_t count;
418 COMM_CHECK_AND_RETURN_RET_LOGE(
419 data.ReadUint32(count), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read count failed");
420 COMM_CHECK_AND_RETURN_RET_LOGE(count < QOS_TYPE_BUTT, SOFTBUS_INVALID_PARAM, COMM_SDK, "invalid count");
421
422 QosTV *qos = (QosTV *)data.ReadBuffer(sizeof(QosTV) * count);
423 COMM_CHECK_AND_RETURN_RET_LOGE(
424 qos != nullptr, SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, COMM_SDK, "read qos failed!");
425
426 int32_t ret = OnClientChannelOnQos(channelId, channelType, (QoSEvent)event, qos, count);
427 if (ret != SOFTBUS_OK) {
428 COMM_LOGE(COMM_SDK, "OnClientChannelOnQos failed, ret=%{public}d", ret);
429 }
430 return SOFTBUS_OK;
431 }
432
SetChannelInfoInner(MessageParcel & data,MessageParcel & reply)433 int32_t SoftBusClientStub::SetChannelInfoInner(MessageParcel &data, MessageParcel &reply)
434 {
435 const char *sessionName = data.ReadCString();
436 COMM_CHECK_AND_RETURN_RET_LOGE(sessionName != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read sessionName failed");
437
438 int32_t sessionId;
439 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(sessionId), SOFTBUS_IPC_ERR, COMM_SDK, "read sessionId failed");
440
441 int32_t channelId;
442 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelId), SOFTBUS_IPC_ERR, COMM_SDK, "read channelId failed");
443
444 int32_t channelType;
445 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelType), SOFTBUS_IPC_ERR, COMM_SDK, "read channelType failed");
446
447 int ret = SetChannelInfo(sessionName, sessionId, channelId, channelType);
448 COMM_CHECK_AND_RETURN_RET_LOGE(
449 reply.WriteInt32(ret), SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, COMM_SDK, "write reply failed");
450
451 return SOFTBUS_OK;
452 }
453
OnJoinLNNResultInner(MessageParcel & data,MessageParcel & reply)454 int32_t SoftBusClientStub::OnJoinLNNResultInner(MessageParcel &data, MessageParcel &reply)
455 {
456 uint32_t addrTypeLen;
457 if (!data.ReadUint32(addrTypeLen) || addrTypeLen != sizeof(ConnectionAddr)) {
458 COMM_LOGE(COMM_SDK, "OnJoinLNNResultInner read addr type failed! length=%{public}d", addrTypeLen);
459 return SOFTBUS_TRANS_PROXY_READUINT_FAILED;
460 }
461 void *addr = (void *)data.ReadRawData(addrTypeLen);
462 if (addr == nullptr) {
463 COMM_LOGE(COMM_SDK, "OnJoinLNNResultInner read addr failed!");
464 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
465 }
466 int32_t retCode;
467 if (!data.ReadInt32(retCode)) {
468 COMM_LOGE(COMM_SDK, "OnJoinLNNResultInner read retCode failed!");
469 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
470 }
471 const char *networkId = nullptr;
472 if (retCode == 0) {
473 networkId = data.ReadCString();
474 if (networkId == nullptr) {
475 COMM_LOGE(COMM_SDK, "OnJoinLNNResultInner read networkId failed!");
476 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
477 }
478 }
479 int32_t retReply = OnJoinLNNResult(addr, addrTypeLen, networkId, retCode);
480 if (retReply != SOFTBUS_OK) {
481 COMM_LOGE(COMM_SDK, "OnJoinLNNResultInner notify join result failed!");
482 }
483 return SOFTBUS_OK;
484 }
485
OnLeaveLNNResultInner(MessageParcel & data,MessageParcel & reply)486 int32_t SoftBusClientStub::OnLeaveLNNResultInner(MessageParcel &data, MessageParcel &reply)
487 {
488 const char *networkId = data.ReadCString();
489 if (networkId == nullptr) {
490 COMM_LOGE(COMM_SDK, "OnLeaveLNNResultInner read networkId failed!");
491 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
492 }
493 int32_t retCode;
494 if (!data.ReadInt32(retCode)) {
495 COMM_LOGE(COMM_SDK, "OnLeaveLNNResultInner read retCode failed!");
496 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
497 }
498 int32_t retReply = OnLeaveLNNResult(networkId, retCode);
499 if (retReply != SOFTBUS_OK) {
500 COMM_LOGE(COMM_SDK, "OnLeaveLNNResultInner notify leave result failed!");
501 }
502 return SOFTBUS_OK;
503 }
504
OnNodeOnlineStateChangedInner(MessageParcel & data,MessageParcel & reply)505 int32_t SoftBusClientStub::OnNodeOnlineStateChangedInner(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_TRANS_PROXY_READCSTRING_FAILED;
511 }
512 bool isOnline = false;
513 if (!data.ReadBool(isOnline)) {
514 COMM_LOGE(COMM_SDK, "OnNodeOnlineStateChangedInner read online state failed!");
515 return SOFTBUS_TRANS_PROXY_READBOOL_FAILED;
516 }
517 uint32_t infoTypeLen;
518 if (!data.ReadUint32(infoTypeLen) || infoTypeLen != sizeof(NodeBasicInfo)) {
519 COMM_LOGE(COMM_SDK, "OnNodeOnlineStateChangedInner read info type failed! length=%{public}d", infoTypeLen);
520 return SOFTBUS_TRANS_PROXY_READUINT_FAILED;
521 }
522 void *info = (void *)data.ReadRawData(infoTypeLen);
523 if (info == nullptr) {
524 COMM_LOGE(COMM_SDK, "OnNodeOnlineStateChangedInner read basic info failed!");
525 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
526 }
527 int32_t retReply = OnNodeOnlineStateChanged(pkgName, isOnline, info, infoTypeLen);
528 COMM_LOGI(COMM_SDK, "notify complete, pkgName=%{public}s, isOnline=%{public}d", pkgName, isOnline);
529 if (!reply.WriteInt32(retReply)) {
530 COMM_LOGE(COMM_SDK, "OnNodeOnlineStateChangedInner write reply failed!");
531 return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
532 }
533 return SOFTBUS_OK;
534 }
535
OnNodeBasicInfoChangedInner(MessageParcel & data,MessageParcel & reply)536 int32_t SoftBusClientStub::OnNodeBasicInfoChangedInner(MessageParcel &data, MessageParcel &reply)
537 {
538 const char *pkgName = data.ReadCString();
539 if (pkgName == nullptr || strlen(pkgName) == 0) {
540 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
541 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
542 }
543 int32_t type;
544 if (!data.ReadInt32(type)) {
545 COMM_LOGE(COMM_SDK, "OnNodeBasicInfoChangedInner read type failed!");
546 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
547 }
548 COMM_LOGD(COMM_SDK, "OnNodeBasicInfoChangedInner type. type=%{public}d", type);
549 uint32_t infoTypeLen;
550 if (!data.ReadUint32(infoTypeLen) || infoTypeLen != sizeof(NodeBasicInfo)) {
551 COMM_LOGE(COMM_SDK, "OnNodeBasicInfoChangedInner read failed! infoTypeLen=%{public}d", infoTypeLen);
552 return SOFTBUS_TRANS_PROXY_READUINT_FAILED;
553 }
554 void *info = (void *)data.ReadRawData(infoTypeLen);
555 if (info == nullptr) {
556 COMM_LOGE(COMM_SDK, "OnNodeBasicInfoChangedInner read basic info failed!");
557 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
558 }
559 int32_t retReply = OnNodeBasicInfoChanged(pkgName, info, infoTypeLen, type);
560 if (!reply.WriteInt32(retReply)) {
561 COMM_LOGE(COMM_SDK, "OnNodeBasicInfoChangedInner write reply failed!");
562 return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
563 }
564 return SOFTBUS_OK;
565 }
566
OnNodeStatusChangedInner(MessageParcel & data,MessageParcel & reply)567 int32_t SoftBusClientStub::OnNodeStatusChangedInner(MessageParcel &data, MessageParcel &reply)
568 {
569 const char *pkgName = data.ReadCString();
570 if (pkgName == nullptr || strlen(pkgName) == 0) {
571 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
572 return SOFTBUS_INVALID_PARAM;
573 }
574 int32_t type;
575 if (!data.ReadInt32(type)) {
576 COMM_LOGE(COMM_SDK, "OnNodeStatusChangedInner read type failed!");
577 return SOFTBUS_NETWORK_READINT32_FAILED;
578 }
579 COMM_LOGD(COMM_SDK, "OnNodeStatusChangedInner type=%{public}d", type);
580 uint32_t infoTypeLen;
581 if (!data.ReadUint32(infoTypeLen) || infoTypeLen != sizeof(NodeStatus)) {
582 COMM_LOGE(COMM_SDK, "OnNodeStatusChangedInner read failed! infoTypeLen=%{public}d", infoTypeLen);
583 return SOFTBUS_NETWORK_READINT32_FAILED;
584 }
585 void *info = (void *)data.ReadRawData(infoTypeLen);
586 if (info == nullptr) {
587 COMM_LOGE(COMM_SDK, "OnNodeStatusChangedInner read node status failed!");
588 return SOFTBUS_NETWORK_READRAWDATA_FAILED;
589 }
590 int32_t retReply = OnNodeStatusChanged(pkgName, info, infoTypeLen, type);
591 if (!reply.WriteInt32(retReply)) {
592 COMM_LOGE(COMM_SDK, "OnNodeStatusChangedInner write reply failed!");
593 return SOFTBUS_NETWORK_WRITEINT32_FAILED;
594 }
595 return SOFTBUS_OK;
596 }
597
OnLocalNetworkIdChangedInner(MessageParcel & data,MessageParcel & reply)598 int32_t SoftBusClientStub::OnLocalNetworkIdChangedInner(MessageParcel &data, MessageParcel &reply)
599 {
600 const char *pkgName = data.ReadCString();
601 if (pkgName == nullptr || strlen(pkgName) == 0) {
602 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
603 return SOFTBUS_INVALID_PARAM;
604 }
605 int32_t retReply = OnLocalNetworkIdChanged(pkgName);
606 if (!reply.WriteInt32(retReply)) {
607 COMM_LOGE(COMM_SDK, "OnLocalNetworkIdChangedInner write reply failed!");
608 return SOFTBUS_IPC_ERR;
609 }
610 return SOFTBUS_OK;
611 }
612
OnNodeDeviceTrustedChangeInner(MessageParcel & data,MessageParcel & reply)613 int32_t SoftBusClientStub::OnNodeDeviceTrustedChangeInner(MessageParcel &data, MessageParcel &reply)
614 {
615 const char *pkgName = data.ReadCString();
616 if (pkgName == nullptr || strlen(pkgName) == 0) {
617 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
618 return SOFTBUS_INVALID_PARAM;
619 }
620 int32_t type = 0;
621 if (!data.ReadInt32(type)) {
622 COMM_LOGE(COMM_SDK, "read type failed!");
623 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
624 }
625 const char *msg = data.ReadCString();
626 if (msg == nullptr) {
627 COMM_LOGE(COMM_SDK, "read msg failed!");
628 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
629 }
630 uint32_t msgLen = 0;
631 if (!data.ReadUint32(msgLen)) {
632 COMM_LOGE(COMM_SDK, "read failed! msgLen=%{public}u", msgLen);
633 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
634 }
635 int32_t retReply = OnNodeDeviceTrustedChange(pkgName, type, msg, msgLen);
636 if (!reply.WriteInt32(retReply)) {
637 COMM_LOGE(COMM_SDK, "write reply failed!");
638 return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
639 }
640 return SOFTBUS_OK;
641 }
642
OnHichainProofExceptionInner(MessageParcel & data,MessageParcel & reply)643 int32_t SoftBusClientStub::OnHichainProofExceptionInner(MessageParcel &data, MessageParcel &reply)
644 {
645 const char *pkgName = data.ReadCString();
646 if (pkgName == nullptr || strlen(pkgName) == 0) {
647 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
648 return SOFTBUS_INVALID_PARAM;
649 }
650 uint32_t proofLen = 0;
651 if (!data.ReadUint32(proofLen)) {
652 COMM_LOGE(COMM_SDK, "read failed! proofLen=%{public}u", proofLen);
653 return SOFTBUS_NETWORK_PROXY_READINT_FAILED;
654 }
655 char *proofInfo = nullptr;
656 if (proofLen != 0) {
657 proofInfo = (char *)data.ReadRawData(proofLen);
658 if (proofInfo == nullptr) {
659 COMM_LOGE(COMM_SDK, "read proofInfo failed!");
660 return SOFTBUS_NETWORK_READRAWDATA_FAILED;
661 }
662 }
663 uint16_t deviceTypeId = 0;
664 if (!data.ReadUint16(deviceTypeId)) {
665 COMM_LOGE(COMM_SDK, "read failed! deviceTypeId=%{public}hu", deviceTypeId);
666 return SOFTBUS_NETWORK_PROXY_READINT_FAILED;
667 }
668 int32_t errCode = 0;
669 if (!data.ReadInt32(errCode)) {
670 COMM_LOGE(COMM_SDK, "read failed! errCode=%{public}d", errCode);
671 return SOFTBUS_NETWORK_PROXY_READINT_FAILED;
672 }
673 int32_t retReply = OnHichainProofException(pkgName, proofInfo, proofLen, deviceTypeId, errCode);
674 if (!reply.WriteInt32(retReply)) {
675 COMM_LOGE(COMM_SDK, "OnHichainProofException write reply failed!");
676 return SOFTBUS_NETWORK_WRITEINT32_FAILED;
677 }
678 return SOFTBUS_OK;
679 }
680
OnTimeSyncResultInner(MessageParcel & data,MessageParcel & reply)681 int32_t SoftBusClientStub::OnTimeSyncResultInner(MessageParcel &data, MessageParcel &reply)
682 {
683 uint32_t infoTypeLen;
684 if (!data.ReadUint32(infoTypeLen) || infoTypeLen != sizeof(TimeSyncResultInfo)) {
685 COMM_LOGE(COMM_SDK, "OnTimeSyncResultInner read info failed! length=%{public}d", infoTypeLen);
686 return SOFTBUS_TRANS_PROXY_READUINT_FAILED;
687 }
688 void *info = (void *)data.ReadRawData(infoTypeLen);
689 if (info == nullptr) {
690 COMM_LOGE(COMM_SDK, "OnTimeSyncResultInner read info failed!");
691 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
692 }
693 int32_t retCode;
694 if (!data.ReadInt32(retCode)) {
695 COMM_LOGE(COMM_SDK, "OnTimeSyncResultInner read retCode failed!");
696 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
697 }
698
699 int32_t retReply = OnTimeSyncResult(info, infoTypeLen, retCode);
700 if (!reply.WriteInt32(retReply)) {
701 COMM_LOGE(COMM_SDK, "OnTimeSyncResultInner write reply failed!");
702 return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
703 }
704 return SOFTBUS_OK;
705 }
706
OnPublishLNNResultInner(MessageParcel & data,MessageParcel & reply)707 int32_t SoftBusClientStub::OnPublishLNNResultInner(MessageParcel &data, MessageParcel &reply)
708 {
709 int32_t publishId;
710 if (!data.ReadInt32(publishId)) {
711 COMM_LOGE(COMM_SDK, "OnPublishLNNResultInner read publishId failed!");
712 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
713 }
714 int32_t reason;
715 if (!data.ReadInt32(reason)) {
716 COMM_LOGE(COMM_SDK, "OnPublishLNNResultInner read reason failed!");
717 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
718 }
719
720 OnPublishLNNResult(publishId, reason);
721 return SOFTBUS_OK;
722 }
723
OnRefreshLNNResultInner(MessageParcel & data,MessageParcel & reply)724 int32_t SoftBusClientStub::OnRefreshLNNResultInner(MessageParcel &data, MessageParcel &reply)
725 {
726 int32_t refreshId;
727 if (!data.ReadInt32(refreshId)) {
728 COMM_LOGE(COMM_SDK, "OnRefreshLNNResultInner read publishId failed!");
729 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
730 }
731 int32_t reason;
732 if (!data.ReadInt32(reason)) {
733 COMM_LOGE(COMM_SDK, "OnRefreshLNNResultInner read reason failed!");
734 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
735 }
736
737 OnRefreshLNNResult(refreshId, reason);
738 return SOFTBUS_OK;
739 }
740
OnRefreshDeviceFoundInner(MessageParcel & data,MessageParcel & reply)741 int32_t SoftBusClientStub::OnRefreshDeviceFoundInner(MessageParcel &data, MessageParcel &reply)
742 {
743 uint32_t deviceLen;
744 if (!data.ReadUint32(deviceLen) || deviceLen != sizeof(DeviceInfo)) {
745 COMM_LOGE(COMM_SDK, "OnRefreshDeviceFoundInner read info failed! length=%{public}d", deviceLen);
746 return SOFTBUS_TRANS_PROXY_READUINT_FAILED;
747 }
748 void *device = (void *)data.ReadRawData(deviceLen);
749 if (device == nullptr) {
750 COMM_LOGE(COMM_SDK, "OnRefreshDeviceFoundInner read info failed!");
751 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
752 }
753 OnRefreshDeviceFound(device, deviceLen);
754 return SOFTBUS_OK;
755 }
756
OnDataLevelChangedInner(MessageParcel & data,MessageParcel & reply)757 int32_t SoftBusClientStub::OnDataLevelChangedInner(MessageParcel &data, MessageParcel &reply)
758 {
759 const char *networkId = data.ReadCString();
760 if (networkId == nullptr || strlen(networkId) == 0) {
761 COMM_LOGE(COMM_SDK, "Invalid network, or length is zero");
762 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
763 }
764
765 DataLevelInfo *info = (DataLevelInfo *)data.ReadRawData(sizeof(DataLevelInfo));
766 if (info == nullptr) {
767 COMM_LOGE(COMM_SDK, "OnDataLevelChangedInner read data level change info failed");
768 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
769 }
770 OnDataLevelChanged(networkId, info);
771 return SOFTBUS_OK;
772 }
773
OnMsdpRangeResultInner(MessageParcel & data,MessageParcel & reply)774 int32_t SoftBusClientStub::OnMsdpRangeResultInner(MessageParcel &data, MessageParcel &reply)
775 {
776 RangeResultInnerInfo *tempInfo = (RangeResultInnerInfo *)data.ReadRawData(sizeof(RangeResultInnerInfo));
777 if (tempInfo == nullptr) {
778 COMM_LOGE(COMM_SDK, "read ble range info failed");
779 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
780 }
781 RangeResultInnerInfo info;
782 (void)memset_s(&info, sizeof(RangeResultInnerInfo), 0, sizeof(RangeResultInnerInfo));
783 if (memcpy_s(&info, sizeof(RangeResultInnerInfo), tempInfo, sizeof(RangeResultInnerInfo)) != EOK) {
784 COMM_LOGE(COMM_SDK, "memcpy_s failed");
785 return SOFTBUS_MEM_ERR;
786 }
787 if (tempInfo->length > 0 && tempInfo->length < MAX_ADDITION_DATA_LEN) {
788 info.addition = (uint8_t *)data.ReadRawData(tempInfo->length);
789 if (info.addition == nullptr) {
790 COMM_LOGE(COMM_SDK, "read addition data failed");
791 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
792 }
793 }
794 char *anonyNetworkId = nullptr;
795 Anonymize(info.networkId, &anonyNetworkId);
796 COMM_LOGI(COMM_SDK, "medium=%{public}d, distance=%{public}f, networkId=%{public}s", info.medium, info.distance,
797 AnonymizeWrapper(anonyNetworkId));
798 AnonymizeFree(anonyNetworkId);
799 OnMsdpRangeResult(&info);
800 return SOFTBUS_OK;
801 }
802
OnChannelBind(int32_t channelId,int32_t channelType)803 int32_t SoftBusClientStub::OnChannelBind(int32_t channelId, int32_t channelType)
804 {
805 return TransOnChannelBind(channelId, channelType);
806 }
807
OnChannelBindInner(MessageParcel & data,MessageParcel & reply)808 int32_t SoftBusClientStub::OnChannelBindInner(MessageParcel &data, MessageParcel &reply)
809 {
810 int32_t channelId;
811 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelId), SOFTBUS_IPC_ERR, COMM_SDK, "read channelId failed");
812
813 int32_t channelType;
814 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelType), SOFTBUS_IPC_ERR, COMM_SDK, "read channelType failed");
815
816 int32_t ret = OnChannelBind(channelId, channelType);
817 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, COMM_SDK,
818 "OnChannelBind failed! ret=%{public}d, channelId=%{public}d, channelType=%{public}d",
819 ret, channelId, channelType);
820
821 return SOFTBUS_OK;
822 }
823
MessageParcelReadCollabInfo(MessageParcel & data,CollabInfo & info)824 static int32_t MessageParcelReadCollabInfo(MessageParcel &data, CollabInfo &info)
825 {
826 const char *accountId = data.ReadCString();
827 if (accountId == nullptr) {
828 COMM_LOGE(COMM_SDK, "read accountId failed");
829 } else {
830 if (strcpy_s(info.accountId, sizeof(info.accountId), accountId) != EOK) {
831 COMM_LOGE(COMM_SDK, "strcpy_s failed to copy accountId");
832 }
833 }
834 READ_PARCEL_WITH_RET(data, Uint64, info.tokenId, SOFTBUS_IPC_ERR);
835 READ_PARCEL_WITH_RET(data, Int32, info.userId, SOFTBUS_IPC_ERR);
836 READ_PARCEL_WITH_RET(data, Int32, info.pid, SOFTBUS_IPC_ERR);
837 const char *deviceId = data.ReadCString();
838 COMM_CHECK_AND_RETURN_RET_LOGE(deviceId != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read deviceId failed");
839 if (strcpy_s(info.deviceId, sizeof(info.deviceId), deviceId) != EOK) {
840 COMM_LOGE(COMM_SDK, "strcpy_s failed to copy deviceId");
841 }
842 return SOFTBUS_OK;
843 }
844
OnCheckCollabRelation(const CollabInfo * sourceInfo,bool isSinkSide,const CollabInfo * sinkInfo,int32_t channelId,int32_t channelType)845 int32_t SoftBusClientStub::OnCheckCollabRelation(
846 const CollabInfo *sourceInfo, bool isSinkSide, const CollabInfo *sinkInfo, int32_t channelId, int32_t channelType)
847 {
848 if (sourceInfo == nullptr || sinkInfo == nullptr) {
849 COMM_LOGE(COMM_SDK, "invalid param.");
850 return SOFTBUS_INVALID_PARAM;
851 }
852 return TransOnCheckCollabRelation(sourceInfo, isSinkSide, sinkInfo, channelId, channelType);
853 }
854
OnCheckCollabRelationInner(MessageParcel & data,MessageParcel & reply)855 int32_t SoftBusClientStub::OnCheckCollabRelationInner(MessageParcel &data, MessageParcel &reply)
856 {
857 CollabInfo sourceInfo;
858 CollabInfo sinkInfo;
859 bool isSinkSide = false;
860 int32_t channelId = -1;
861 int32_t channelType = -1;
862 READ_PARCEL_WITH_RET(data, Bool, isSinkSide, SOFTBUS_IPC_ERR);
863 int32_t ret = MessageParcelReadCollabInfo(data, sourceInfo);
864 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, COMM_SDK, "read source info failed");
865 ret = MessageParcelReadCollabInfo(data, sinkInfo);
866 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, COMM_SDK, "read sink info failed");
867 if (isSinkSide) {
868 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelId), SOFTBUS_IPC_ERR, COMM_SDK, "read channelId failed");
869 COMM_CHECK_AND_RETURN_RET_LOGE(
870 data.ReadInt32(channelType), SOFTBUS_IPC_ERR, COMM_SDK, "read channelType failed");
871 }
872 ret = OnCheckCollabRelation(&sourceInfo, isSinkSide, &sinkInfo, channelId, channelType);
873 COMM_CHECK_AND_RETURN_RET_LOGE(
874 ret == SOFTBUS_OK, ret, COMM_SDK, "CheckCollabRelation failed! ret=%{public}d.", ret);
875 return SOFTBUS_OK;
876 }
877
OnBrProxyOpenedInner(MessageParcel & data,MessageParcel & reply)878 int32_t SoftBusClientStub::OnBrProxyOpenedInner(MessageParcel &data, MessageParcel &reply)
879 {
880 int32_t channelId;
881 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelId), SOFTBUS_IPC_ERR, COMM_SDK, "read channelId failed");
882 char *brMac = (char *)data.ReadCString();
883 COMM_CHECK_AND_RETURN_RET_LOGE(brMac != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read brMac failed");
884 char *uuid = (char *)data.ReadCString();
885 COMM_CHECK_AND_RETURN_RET_LOGE(uuid != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read uuid failed");
886 int32_t reason;
887 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(reason), SOFTBUS_IPC_ERR, COMM_SDK, "read reason failed");
888
889 return ClientTransOnBrProxyOpened(channelId, brMac, uuid, reason);
890 }
891
OnBrProxyDataRecvInner(MessageParcel & data,MessageParcel & reply)892 int32_t SoftBusClientStub::OnBrProxyDataRecvInner(MessageParcel &data, MessageParcel &reply)
893 {
894 int32_t channelId;
895 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelId), SOFTBUS_IPC_ERR, COMM_SDK, "read channelId failed");
896 uint32_t len;
897 COMM_CHECK_AND_RETURN_RET_LOGE(
898 data.ReadUint32(len), SOFTBUS_TRANS_PROXY_READUINT_FAILED, COMM_SDK, "read data len failed");
899 uint8_t *dataInfo = (uint8_t *)data.ReadRawData(len);
900 COMM_CHECK_AND_RETURN_RET_LOGE(
901 dataInfo != nullptr, SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, COMM_SDK, "read dataInfo failed!");
902
903 return ClientTransBrProxyDataReceived(channelId, dataInfo, len);
904 }
905
OnBrProxyStateChangedInner(MessageParcel & data,MessageParcel & reply)906 int32_t SoftBusClientStub::OnBrProxyStateChangedInner(MessageParcel &data, MessageParcel &reply)
907 {
908 int32_t channelId;
909 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelId), SOFTBUS_IPC_ERR, COMM_SDK, "read channelId failed");
910 int32_t errCode;
911 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(errCode), SOFTBUS_IPC_ERR, COMM_SDK, "read errCode failed");
912
913 return ClientTransBrProxyChannelChange(channelId, errCode);
914 }
915
OnBrProxyQueryPermissionInner(MessageParcel & data,MessageParcel & reply)916 int32_t SoftBusClientStub::OnBrProxyQueryPermissionInner(MessageParcel &data, MessageParcel &reply)
917 {
918 char *bundleName = (char *)data.ReadCString();
919 bool isEmpowered = false;
920
921 int32_t ret = ClientTransBrProxyQueryPermission(bundleName, &isEmpowered);
922 COMM_LOGI(COMM_SDK, "[br_proxy] ret:%{public}d", ret);
923
924 if (!reply.WriteBool(isEmpowered)) {
925 COMM_LOGE(COMM_SDK, "OnTimeSyncResultInner write reply failed!");
926 return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
927 }
928
929 return SOFTBUS_OK;
930 }
931
OnJoinLNNResult(void * addr,uint32_t addrTypeLen,const char * networkId,int retCode)932 int32_t SoftBusClientStub::OnJoinLNNResult(void *addr, uint32_t addrTypeLen, const char *networkId, int retCode)
933 {
934 (void)addrTypeLen;
935 return LnnOnJoinResult(addr, networkId, retCode);
936 }
937
OnLeaveLNNResult(const char * networkId,int retCode)938 int32_t SoftBusClientStub::OnLeaveLNNResult(const char *networkId, int retCode)
939 {
940 return LnnOnLeaveResult(networkId, retCode);
941 }
942
OnNodeOnlineStateChanged(const char * pkgName,bool isOnline,void * info,uint32_t infoTypeLen)943 int32_t SoftBusClientStub::OnNodeOnlineStateChanged(const char *pkgName, bool isOnline,
944 void *info, uint32_t infoTypeLen)
945 {
946 (void)infoTypeLen;
947 return LnnOnNodeOnlineStateChanged(pkgName, isOnline, info);
948 }
949
OnNodeBasicInfoChanged(const char * pkgName,void * info,uint32_t infoTypeLen,int32_t type)950 int32_t SoftBusClientStub::OnNodeBasicInfoChanged(const char *pkgName, void *info, uint32_t infoTypeLen, int32_t type)
951 {
952 (void)infoTypeLen;
953 return LnnOnNodeBasicInfoChanged(pkgName, info, type);
954 }
955
OnNodeStatusChanged(const char * pkgName,void * info,uint32_t infoTypeLen,int32_t type)956 int32_t SoftBusClientStub::OnNodeStatusChanged(const char *pkgName, void *info, uint32_t infoTypeLen, int32_t type)
957 {
958 (void)infoTypeLen;
959 return LnnOnNodeStatusChanged(pkgName, info, type);
960 }
961
OnLocalNetworkIdChanged(const char * pkgName)962 int32_t SoftBusClientStub::OnLocalNetworkIdChanged(const char *pkgName)
963 {
964 return LnnOnLocalNetworkIdChanged(pkgName);
965 }
966
OnNodeDeviceTrustedChange(const char * pkgName,int32_t type,const char * msg,uint32_t msgLen)967 int32_t SoftBusClientStub::OnNodeDeviceTrustedChange(const char *pkgName, int32_t type, const char *msg,
968 uint32_t msgLen)
969 {
970 return LnnOnNodeDeviceTrustedChange(pkgName, type, msg, msgLen);
971 }
972
OnHichainProofException(const char * pkgName,const char * proofInfo,uint32_t proofLen,uint16_t deviceTypeId,int32_t errCode)973 int32_t SoftBusClientStub::OnHichainProofException(
974 const char *pkgName, const char *proofInfo, uint32_t proofLen, uint16_t deviceTypeId, int32_t errCode)
975 {
976 return LnnOnHichainProofException(pkgName, proofInfo, proofLen, deviceTypeId, errCode);
977 }
978
OnTimeSyncResult(const void * info,uint32_t infoTypeLen,int32_t retCode)979 int32_t SoftBusClientStub::OnTimeSyncResult(const void *info, uint32_t infoTypeLen, int32_t retCode)
980 {
981 (void)infoTypeLen;
982 return LnnOnTimeSyncResult(info, retCode);
983 }
984
OnPublishLNNResult(int32_t publishId,int32_t reason)985 void SoftBusClientStub::OnPublishLNNResult(int32_t publishId, int32_t reason)
986 {
987 LnnOnPublishLNNResult(publishId, reason);
988 }
989
OnRefreshLNNResult(int32_t refreshId,int32_t reason)990 void SoftBusClientStub::OnRefreshLNNResult(int32_t refreshId, int32_t reason)
991 {
992 LnnOnRefreshLNNResult(refreshId, reason);
993 }
994
OnRefreshDeviceFound(const void * device,uint32_t deviceLen)995 void SoftBusClientStub::OnRefreshDeviceFound(const void *device, uint32_t deviceLen)
996 {
997 (void)deviceLen;
998 LnnOnRefreshDeviceFound(device);
999 }
1000
OnDataLevelChanged(const char * networkId,const DataLevelInfo * dataLevelInfo)1001 void SoftBusClientStub::OnDataLevelChanged(const char *networkId, const DataLevelInfo *dataLevelInfo)
1002 {
1003 LnnOnDataLevelChanged(networkId, dataLevelInfo);
1004 }
1005
OnMsdpRangeResult(const RangeResultInnerInfo * rangeInfo)1006 void SoftBusClientStub::OnMsdpRangeResult(const RangeResultInnerInfo *rangeInfo)
1007 {
1008 LnnOnRangeResult(rangeInfo);
1009 }
1010
OnClientChannelOnQos(int32_t channelId,int32_t channelType,QoSEvent event,const QosTV * qos,uint32_t count)1011 int32_t SoftBusClientStub::OnClientChannelOnQos(
1012 int32_t channelId, int32_t channelType, QoSEvent event, const QosTV *qos, uint32_t count)
1013 {
1014 if (event < QOS_SATISFIED || event > QOS_NOT_SATISFIED) {
1015 COMM_LOGE(COMM_SDK, "OnChannelOnQos invalid event=%{public}d", event);
1016 return SOFTBUS_INVALID_PARAM;
1017 }
1018 if (qos == nullptr || count == 0) {
1019 COMM_LOGE(COMM_SDK, "OnChannelOnQos invalid qos or count");
1020 return SOFTBUS_INVALID_PARAM;
1021 }
1022 return TransOnChannelOnQos(channelId, channelType, event, qos, count);
1023 }
1024
OnConnectionStateChangeInner(MessageParcel & data,MessageParcel & reply)1025 int32_t SoftBusClientStub::OnConnectionStateChangeInner(MessageParcel &data, MessageParcel &reply)
1026 {
1027 uint32_t handle;
1028 if (!data.ReadUint32(handle)) {
1029 COMM_LOGE(COMM_SDK, "OnConnectionStateChangeInner read handle failed!");
1030 return SOFTBUS_IPC_ERR;
1031 }
1032 int32_t state;
1033 if (!data.ReadInt32(state)) {
1034 COMM_LOGE(COMM_SDK, "OnConnectionStateChangeInner read state failed!");
1035 return SOFTBUS_IPC_ERR;
1036 }
1037 int32_t reason;
1038 if (!data.ReadInt32(reason)) {
1039 COMM_LOGE(COMM_SDK, "OnConnectionStateChangeInner read reason failed!");
1040 return SOFTBUS_IPC_ERR;
1041 }
1042 int32_t ret = OnConnectionStateChange(handle, state, reason);
1043 if (ret != SOFTBUS_OK) {
1044 COMM_LOGE(COMM_SDK, "OnConnectionStateChangeInner failed! ret=%{public}d", ret);
1045 }
1046 return SOFTBUS_OK;
1047 }
1048
OnAcceptConnectInner(MessageParcel & data,MessageParcel & reply)1049 int32_t SoftBusClientStub::OnAcceptConnectInner(MessageParcel &data, MessageParcel &reply)
1050 {
1051 char *name = (char *)data.ReadCString();
1052 if (name == nullptr) {
1053 COMM_LOGE(COMM_SDK, "OnAcceptConnectInner read name failed!");
1054 return SOFTBUS_IPC_ERR;
1055 }
1056 uint32_t handle;
1057 if (!data.ReadUint32(handle)) {
1058 COMM_LOGE(COMM_SDK, "OnAcceptConnectInner read handle failed!");
1059 return SOFTBUS_IPC_ERR;
1060 }
1061 int32_t ret = OnAcceptConnect(name, handle);
1062 if (ret != SOFTBUS_OK) {
1063 COMM_LOGE(COMM_SDK, "OnAcceptConnectInner failed! ret=%{public}d", ret);
1064 }
1065 return SOFTBUS_OK;
1066 }
1067
OnDataReceivedInner(MessageParcel & data,MessageParcel & reply)1068 int32_t SoftBusClientStub::OnDataReceivedInner(MessageParcel &data, MessageParcel &reply)
1069 {
1070 uint32_t handle;
1071 if (!data.ReadUint32(handle)) {
1072 COMM_LOGE(COMM_SDK, "OnDataReceivedInner read handle failed!");
1073 return SOFTBUS_IPC_ERR;
1074 }
1075 uint32_t len;
1076 if (!data.ReadUint32(len)) {
1077 COMM_LOGE(COMM_SDK, "OnDataReceivedInner read len failed!");
1078 return SOFTBUS_IPC_ERR;
1079 }
1080 const uint8_t *dataPtr = (const uint8_t *)data.ReadBuffer(len);
1081 if (dataPtr == nullptr) {
1082 COMM_LOGE(COMM_SDK, "OnDataReceivedInner read data failed!");
1083 return SOFTBUS_IPC_ERR;
1084 }
1085 int32_t ret = OnDataReceived(handle, dataPtr, len);
1086 if (ret != SOFTBUS_OK) {
1087 COMM_LOGE(COMM_SDK, "OnDataReceivedInner failed! ret=%{public}d", ret);
1088 }
1089 return SOFTBUS_OK;
1090 }
1091
OnConnectionStateChange(uint32_t handle,int32_t state,int32_t reason)1092 int32_t SoftBusClientStub::OnConnectionStateChange(uint32_t handle, int32_t state, int32_t reason)
1093 {
1094 COMM_LOGI(COMM_SDK, "OnConnectionStateChange handle=%{public}d, state=%{public}d, reason=%{public}d", handle, state,
1095 reason);
1096 return ConnectionStateChange(handle, state, reason);
1097 }
1098
OnAcceptConnect(const char * name,uint32_t handle)1099 int32_t SoftBusClientStub::OnAcceptConnect(const char *name, uint32_t handle)
1100 {
1101 COMM_LOGI(COMM_SDK, "OnAcceptConnect name=%{public}s, handle=%{public}d", name, handle);
1102 return AcceptConnect(name, handle);
1103 }
1104
OnDataReceived(uint32_t handle,const uint8_t * data,uint32_t len)1105 int32_t SoftBusClientStub::OnDataReceived(uint32_t handle, const uint8_t *data, uint32_t len)
1106 {
1107 COMM_LOGI(COMM_SDK, "OnDataReceived handle=%{public}d, len=%{public}u", handle, len);
1108 DataReceived(handle, data, len);
1109 return SOFTBUS_OK;
1110 }
1111 } // namespace OHOS
1112