1 /*
2  * Copyright (c) 2021-2023 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 "bus_center_server_proxy_standard.h"
17 
18 #include <securec.h>
19 #include "bus_center_server_proxy.h"
20 #include "ipc_skeleton.h"
21 #include "iremote_broker.h"
22 #include "iremote_object.h"
23 #include "iremote_proxy.h"
24 #include "lnn_log.h"
25 #include "message_parcel.h"
26 #include "softbus_adapter_mem.h"
27 #include "softbus_errcode.h"
28 #include "softbus_feature_config.h"
29 #include "softbus_server_ipc_interface_code.h"
30 
31 namespace OHOS {
32 sptr<IRemoteObject> g_remoteProxy = nullptr;
33 uint32_t g_getSystemAbilityId = 2;
34 const std::u16string SAMANAGER_INTERFACE_TOKEN = u"ohos.samgr.accessToken";
GetSystemAbility()35 static sptr<IRemoteObject> GetSystemAbility()
36 {
37     MessageParcel data;
38 
39     if (!data.WriteInterfaceToken(SAMANAGER_INTERFACE_TOKEN)) {
40         return nullptr;
41     }
42 
43     data.WriteInt32(SOFTBUS_SERVER_SA_ID_INNER);
44     MessageParcel reply;
45     MessageOption option;
46     sptr<IRemoteObject> samgr = IPCSkeleton::GetContextObject();
47     if (samgr == nullptr) {
48         LNN_LOGE(LNN_EVENT, "Get samgr failed");
49         return nullptr;
50     }
51     int32_t err = samgr->SendRequest(g_getSystemAbilityId, data, reply, option);
52     if (err != 0) {
53         LNN_LOGE(LNN_EVENT, "GetSystemAbility failed=%{public}d", err);
54         return nullptr;
55     }
56     return reply.ReadRemoteObject();
57 }
58 
BusCenterServerProxyStandardInit(void)59 int32_t BusCenterServerProxy::BusCenterServerProxyStandardInit(void)
60 {
61     if (g_remoteProxy != nullptr) {
62         LNN_LOGE(LNN_EVENT, "init success");
63         return SOFTBUS_OK;
64     }
65     g_remoteProxy = GetSystemAbility();
66     if (g_remoteProxy == nullptr) {
67         LNN_LOGE(LNN_EVENT, "get system ability fail");
68         return SOFTBUS_ERR;
69     }
70     return SOFTBUS_OK;
71 }
72 
BusCenterServerProxyStandardDeInit(void)73 void BusCenterServerProxy::BusCenterServerProxyStandardDeInit(void)
74 {
75     g_remoteProxy.clear();
76 }
77 
SoftbusRegisterService(const char * clientPkgName,const sptr<IRemoteObject> & object)78 int32_t BusCenterServerProxy::SoftbusRegisterService(const char *clientPkgName, const sptr<IRemoteObject>& object)
79 {
80     return SOFTBUS_OK;
81 }
82 
CreateSessionServer(const char * pkgName,const char * sessionName)83 int32_t BusCenterServerProxy::CreateSessionServer(const char *pkgName, const char *sessionName)
84 {
85     return SOFTBUS_OK;
86 }
87 
RemoveSessionServer(const char * pkgName,const char * sessionName)88 int32_t BusCenterServerProxy::RemoveSessionServer(const char *pkgName, const char *sessionName)
89 {
90     return SOFTBUS_OK;
91 }
92 
OpenSession(const SessionParam * param,TransInfo * info)93 int32_t BusCenterServerProxy::OpenSession(const SessionParam *param, TransInfo *info)
94 {
95     return SOFTBUS_OK;
96 }
97 
OpenAuthSession(const char * sessionName,const ConnectionAddr * addrInfo)98 int32_t BusCenterServerProxy::OpenAuthSession(const char *sessionName, const ConnectionAddr *addrInfo)
99 {
100     return SOFTBUS_OK;
101 }
102 
NotifyAuthSuccess(int32_t channelId,int32_t channelType)103 int32_t BusCenterServerProxy::NotifyAuthSuccess(int32_t channelId, int32_t channelType)
104 {
105     (void)channelId;
106     (void)channelType;
107     return SOFTBUS_OK;
108 }
109 
ReleaseResources(int32_t channelId)110 int32_t BusCenterServerProxy::ReleaseResources(int32_t channelId)
111 {
112     (void)channelId;
113     return SOFTBUS_OK;
114 }
115 
CloseChannel(const char * sessionName,int32_t channelId,int32_t channelType)116 int32_t BusCenterServerProxy::CloseChannel(const char *sessionName, int32_t channelId, int32_t channelType)
117 {
118     (void)sessionName;
119     (void)channelId;
120     (void)channelType;
121     return SOFTBUS_OK;
122 }
123 
CloseChannelWithStatistics(int32_t channelId,int32_t channelType,uint64_t laneId,const void * dataInfo,uint32_t len)124 int32_t BusCenterServerProxy::CloseChannelWithStatistics(int32_t channelId, int32_t channelType, uint64_t laneId,
125     const void *dataInfo, uint32_t len)
126 {
127     (void)channelId;
128     (void)channelType;
129     (void)laneId;
130     (void)dataInfo;
131     (void)len;
132     return SOFTBUS_OK;
133 }
134 
SendMessage(int32_t channelId,int32_t channelType,const void * data,uint32_t len,int32_t msgType)135 int32_t BusCenterServerProxy::SendMessage(int32_t channelId, int32_t channelType, const void *data,
136     uint32_t len, int32_t msgType)
137 {
138     return SOFTBUS_OK;
139 }
140 
QosReport(int32_t channelId,int32_t chanType,int32_t appType,int32_t quality)141 int32_t BusCenterServerProxy::QosReport(int32_t channelId, int32_t chanType, int32_t appType, int32_t quality)
142 {
143     return SOFTBUS_OK;
144 }
145 
StreamStats(int32_t channelId,int32_t channelType,const StreamSendStats * data)146 int32_t BusCenterServerProxy::StreamStats(int32_t channelId, int32_t channelType, const StreamSendStats *data)
147 {
148     return SOFTBUS_OK;
149 }
150 
RippleStats(int32_t channelId,int32_t channelType,const TrafficStats * data)151 int32_t BusCenterServerProxy::RippleStats(int32_t channelId, int32_t channelType, const TrafficStats *data)
152 {
153     return SOFTBUS_OK;
154 }
155 
JoinLNN(const char * pkgName,void * addr,uint32_t addrTypeLen)156 int32_t BusCenterServerProxy::JoinLNN(const char *pkgName, void *addr, uint32_t addrTypeLen)
157 {
158     if (pkgName == nullptr || addr == nullptr) {
159         return SOFTBUS_INVALID_PARAM;
160     }
161     sptr<IRemoteObject> remote = GetSystemAbility();
162     if (remote == nullptr) {
163         LNN_LOGE(LNN_EVENT, "remote is nullptr");
164         return SOFTBUS_IPC_ERR;
165     }
166 
167     MessageParcel data;
168     if (!data.WriteInterfaceToken(GetDescriptor())) {
169         LNN_LOGE(LNN_EVENT, "write InterfaceToken failed");
170         return SOFTBUS_IPC_ERR;
171     }
172     if (!data.WriteCString(pkgName)) {
173         LNN_LOGE(LNN_EVENT, "write client name failed");
174         return SOFTBUS_IPC_ERR;
175     }
176     if (!data.WriteUint32(addrTypeLen)) {
177         LNN_LOGE(LNN_EVENT, "write addr type length failed");
178         return SOFTBUS_IPC_ERR;
179     }
180     if (!data.WriteRawData(addr, addrTypeLen)) {
181         LNN_LOGE(LNN_EVENT, "write addr failed");
182         return SOFTBUS_IPC_ERR;
183     }
184     MessageParcel reply;
185     MessageOption option;
186     if (remote->SendRequest(SERVER_JOIN_LNN, data, reply, option) != 0) {
187         LNN_LOGE(LNN_EVENT, "send request failed");
188         return SOFTBUS_IPC_ERR;
189     }
190     int32_t serverRet = 0;
191     if (!reply.ReadInt32(serverRet)) {
192         LNN_LOGE(LNN_EVENT, "read serverRet failed");
193         return SOFTBUS_IPC_ERR;
194     }
195     return serverRet;
196 }
197 
LeaveLNN(const char * pkgName,const char * networkId)198 int32_t BusCenterServerProxy::LeaveLNN(const char *pkgName, const char *networkId)
199 {
200     if (pkgName == nullptr || networkId == nullptr) {
201         return SOFTBUS_INVALID_PARAM;
202     }
203     sptr<IRemoteObject> remote = GetSystemAbility();
204     if (remote == nullptr) {
205         LNN_LOGE(LNN_EVENT, "remote is nullptr");
206         return SOFTBUS_IPC_ERR;
207     }
208 
209     MessageParcel data;
210     if (!data.WriteInterfaceToken(GetDescriptor())) {
211         LNN_LOGE(LNN_EVENT, "write InterfaceToken failed");
212         return SOFTBUS_IPC_ERR;
213     }
214     int32_t ret = data.WriteCString(pkgName);
215     if (!ret) {
216         LNN_LOGE(LNN_EVENT, "write client name failed");
217         return SOFTBUS_IPC_ERR;
218     }
219     ret = data.WriteCString(networkId);
220     if (!ret) {
221         LNN_LOGE(LNN_EVENT, "write networkId failed");
222         return SOFTBUS_IPC_ERR;
223     }
224 
225     MessageParcel reply;
226     MessageOption option;
227     int32_t err = remote->SendRequest(SERVER_LEAVE_LNN, data, reply, option);
228     if (err != 0) {
229         LNN_LOGE(LNN_EVENT, "send request failed");
230         return SOFTBUS_IPC_ERR;
231     }
232     int32_t serverRet = 0;
233     ret = reply.ReadInt32(serverRet);
234     if (!ret) {
235         LNN_LOGE(LNN_EVENT, "read serverRet failed");
236         return SOFTBUS_IPC_ERR;
237     }
238     return serverRet;
239 }
240 
WriteSendRequestMessage(const char * pkgName,MessageParcel * data,uint32_t infoTypeLen)241 static bool WriteSendRequestMessage(const char *pkgName, MessageParcel *data, uint32_t infoTypeLen)
242 {
243     if (!data->WriteInterfaceToken(BusCenterServerProxy::GetDescriptor())) {
244         LNN_LOGE(LNN_EVENT, "write InterfaceToken failed");
245         return false;
246     }
247     int32_t ret = data->WriteCString(pkgName);
248     if (!ret) {
249         LNN_LOGE(LNN_EVENT, "write client name failed");
250         return false;
251     }
252     if (!data->WriteUint32(infoTypeLen)) {
253         LNN_LOGE(LNN_EVENT, "write info type length failed");
254         return false;
255     }
256     return true;
257 }
258 
ReadIPCReceiveOnlineNodeInfo(void ** info,uint32_t infoTypeLen,int32_t * infoNum,MessageParcel * reply)259 static int32_t ReadIPCReceiveOnlineNodeInfo(void **info, uint32_t infoTypeLen, int32_t *infoNum, MessageParcel* reply)
260 {
261     if (!reply->ReadInt32(*infoNum)) {
262         LNN_LOGE(LNN_EVENT, "read infoNum failed");
263         return SOFTBUS_IPC_ERR;
264     }
265     uint32_t maxConnCount = UINT32_MAX;
266     (void)SoftbusGetConfig(SOFTBUS_INT_MAX_LNN_CONNECTION_CNT, (unsigned char *)&maxConnCount, sizeof(maxConnCount));
267 
268     if ((*infoNum) < 0 || (uint32_t)(*infoNum) > maxConnCount) {
269         LNN_LOGE(LNN_EVENT, "invalid param, infoNum=%{public}d, maxConnCount=%{public}u", *infoNum, maxConnCount);
270         return SOFTBUS_IPC_ERR;
271     }
272     *info = nullptr;
273     if ((*infoNum) > 0 && (uint32_t)(*infoNum) <= maxConnCount) {
274         uint32_t infoSize = (uint32_t)(*infoNum) * infoTypeLen;
275         void *nodeInfo = const_cast<void *>(reply->ReadRawData(infoSize));
276         if (nodeInfo == nullptr) {
277             LNN_LOGE(LNN_EVENT, "read node info failed");
278             return SOFTBUS_IPC_ERR;
279         }
280         *info = SoftBusMalloc(infoSize);
281         if (*info == nullptr) {
282             LNN_LOGE(LNN_EVENT, "malloc failed");
283             return SOFTBUS_MALLOC_ERR;
284         }
285         if (memcpy_s(*info, infoSize, nodeInfo, infoSize) != EOK) {
286             LNN_LOGE(LNN_EVENT, "copy node info failed");
287             SoftBusFree(*info);
288             *info = nullptr;
289             return SOFTBUS_MEM_ERR;
290         }
291     }
292     return SOFTBUS_OK;
293 }
294 
GetAllOnlineNodeInfo(const char * pkgName,void ** info,uint32_t infoTypeLen,int32_t * infoNum)295 int32_t BusCenterServerProxy::GetAllOnlineNodeInfo(const char *pkgName, void **info, uint32_t infoTypeLen,
296     int32_t *infoNum)
297 {
298     if (pkgName == nullptr || info == nullptr || infoNum == nullptr) {
299         return SOFTBUS_INVALID_PARAM;
300     }
301     sptr<IRemoteObject> remote = GetSystemAbility();
302     if (remote == nullptr) {
303         LNN_LOGE(LNN_EVENT, "remote is nullptr");
304         return SOFTBUS_IPC_ERR;
305     }
306     MessageParcel data;
307     if (!WriteSendRequestMessage(pkgName, &data, infoTypeLen)) {
308         return SOFTBUS_IPC_ERR;
309     }
310     MessageParcel reply;
311     MessageOption option;
312     if (remote->SendRequest(SERVER_GET_ALL_ONLINE_NODE_INFO, data, reply, option) != 0) {
313         LNN_LOGE(LNN_EVENT, "send request failed");
314         return SOFTBUS_IPC_ERR;
315     }
316     return ReadIPCReceiveOnlineNodeInfo(info, infoTypeLen, infoNum, &reply);
317 }
318 
GetLocalDeviceInfo(const char * pkgName,void * info,uint32_t infoTypeLen)319 int32_t BusCenterServerProxy::GetLocalDeviceInfo(const char *pkgName, void *info, uint32_t infoTypeLen)
320 {
321     if (pkgName == nullptr || info == nullptr) {
322         return SOFTBUS_INVALID_PARAM;
323     }
324     if (g_remoteProxy == nullptr) {
325         LNN_LOGE(LNN_EVENT, "g_remoteProxy is nullptr");
326         return SOFTBUS_IPC_ERR;
327     }
328     MessageParcel data;
329     if (!data.WriteInterfaceToken(GetDescriptor())) {
330         LNN_LOGE(LNN_EVENT, "write InterfaceToken failed");
331         return SOFTBUS_IPC_ERR;
332     }
333     if (!data.WriteCString(pkgName)) {
334         LNN_LOGE(LNN_EVENT, "write client name failed");
335         return SOFTBUS_IPC_ERR;
336     }
337     if (!data.WriteUint32(infoTypeLen)) {
338         LNN_LOGE(LNN_EVENT, "write info type length failed");
339         return SOFTBUS_IPC_ERR;
340     }
341     MessageParcel reply;
342     MessageOption option;
343     if (g_remoteProxy->SendRequest(SERVER_GET_LOCAL_DEVICE_INFO, data, reply, option) != 0) {
344         LNN_LOGE(LNN_EVENT, "send request failed");
345         return SOFTBUS_IPC_ERR;
346     }
347     void *nodeInfo = const_cast<void *>(reply.ReadRawData(infoTypeLen));
348     if (nodeInfo == nullptr) {
349         LNN_LOGE(LNN_EVENT, "read node info failed");
350         return SOFTBUS_IPC_ERR;
351     }
352     if (memcpy_s(info, infoTypeLen, nodeInfo, infoTypeLen) != EOK) {
353         LNN_LOGE(LNN_EVENT, "copy node info failed");
354         return SOFTBUS_MEM_ERR;
355     }
356     return SOFTBUS_OK;
357 }
358 
GetNodeKeyInfo(const char * pkgName,const char * networkId,int32_t key,unsigned char * buf,uint32_t len)359 int32_t BusCenterServerProxy::GetNodeKeyInfo(const char *pkgName, const char *networkId, int32_t key,
360     unsigned char *buf, uint32_t len)
361 {
362     if (pkgName == nullptr || networkId == nullptr || buf == nullptr) {
363         LNN_LOGE(LNN_EVENT, "params are nullptr");
364         return SOFTBUS_INVALID_PARAM;
365     }
366     sptr<IRemoteObject> remote = GetSystemAbility();
367     if (remote == nullptr) {
368         LNN_LOGE(LNN_EVENT, "remote is nullptr");
369         return SOFTBUS_IPC_ERR;
370     }
371 
372     MessageParcel data;
373     if (!data.WriteInterfaceToken(GetDescriptor())) {
374         LNN_LOGE(LNN_EVENT, "write InterfaceToken failed");
375         return SOFTBUS_IPC_ERR;
376     }
377     if (!data.WriteCString(pkgName) || !data.WriteCString(networkId)) {
378         LNN_LOGE(LNN_EVENT, "write client name or networkId failed");
379         return SOFTBUS_IPC_ERR;
380     }
381     if (!data.WriteInt32(key) || !data.WriteUint32(len)) {
382         LNN_LOGE(LNN_EVENT, "write key or buf len failed");
383         return SOFTBUS_IPC_ERR;
384     }
385     MessageParcel reply;
386     MessageOption option;
387     if (remote->SendRequest(SERVER_GET_NODE_KEY_INFO, data, reply, option) != 0) {
388         LNN_LOGE(LNN_EVENT, "send request failed");
389         return SOFTBUS_IPC_ERR;
390     }
391     int32_t infoLen;
392     if (!reply.ReadInt32(infoLen) || infoLen <= 0 || (uint32_t)infoLen > len) {
393         LNN_LOGE(LNN_EVENT,
394             "read infoLen failed, len=%{public}u, infoLen=%{public}d", len, infoLen);
395         return SOFTBUS_IPC_ERR;
396     }
397     void *retBuf = const_cast<void *>(reply.ReadRawData(infoLen));
398     if (retBuf == nullptr) {
399         LNN_LOGE(LNN_EVENT, "read retBuf failed");
400         return SOFTBUS_IPC_ERR;
401     }
402     if (memcpy_s(buf, len, retBuf, infoLen) != EOK) {
403         LNN_LOGE(LNN_EVENT, "copy node key info failed");
404         return SOFTBUS_MEM_ERR;
405     }
406     return SOFTBUS_OK;
407 }
408 
SetNodeDataChangeFlag(const char * pkgName,const char * networkId,uint16_t dataChangeFlag)409 int32_t BusCenterServerProxy::SetNodeDataChangeFlag(const char *pkgName, const char *networkId, uint16_t dataChangeFlag)
410 {
411     if (pkgName == nullptr || networkId == nullptr) {
412         LNN_LOGE(LNN_EVENT, "params are nullptr");
413         return SOFTBUS_INVALID_PARAM;
414     }
415     sptr<IRemoteObject> remote = GetSystemAbility();
416     if (remote == nullptr) {
417         LNN_LOGE(LNN_EVENT, "remote is nullptr");
418         return SOFTBUS_IPC_ERR;
419     }
420 
421     MessageParcel data;
422     if (!data.WriteInterfaceToken(GetDescriptor())) {
423         LNN_LOGE(LNN_EVENT, "write InterfaceToken failed");
424         return SOFTBUS_IPC_ERR;
425     }
426     if (!data.WriteCString(pkgName)) {
427         LNN_LOGE(LNN_EVENT, "write client name failed");
428         return SOFTBUS_IPC_ERR;
429     }
430     if (!data.WriteCString(networkId)) {
431         LNN_LOGE(LNN_EVENT, "write networkId failed");
432         return SOFTBUS_IPC_ERR;
433     }
434     if (!data.WriteUint16(dataChangeFlag)) {
435         LNN_LOGE(LNN_EVENT, "write key failed");
436         return SOFTBUS_IPC_ERR;
437     }
438     MessageParcel reply;
439     MessageOption option;
440     if (remote->SendRequest(SERVER_SET_NODE_DATA_CHANGE_FLAG, data, reply, option) != 0) {
441         LNN_LOGE(LNN_EVENT, "send request failed");
442         return SOFTBUS_IPC_ERR;
443     }
444     int32_t serverRet = 0;
445     if (!reply.ReadInt32(serverRet)) {
446         LNN_LOGE(LNN_EVENT, "read serverRet failed");
447         return SOFTBUS_IPC_ERR;
448     }
449     return serverRet;
450 }
451 
RegDataLevelChangeCb(const char * pkgName)452 int32_t BusCenterServerProxy::RegDataLevelChangeCb(const char *pkgName)
453 {
454     if (pkgName == nullptr) {
455         LNN_LOGE(LNN_EVENT, "pkgName is nullptr");
456         return SOFTBUS_INVALID_PARAM;
457     }
458     sptr<IRemoteObject> remote = GetSystemAbility();
459     if (remote == nullptr) {
460         LNN_LOGE(LNN_EVENT, "remote is nullptr");
461         return SOFTBUS_IPC_ERR;
462     }
463     MessageParcel data;
464     if (!data.WriteInterfaceToken(GetDescriptor())) {
465         LNN_LOGE(LNN_EVENT, "write InterfaceToken failed");
466         return SOFTBUS_IPC_ERR;
467     }
468     if (!data.WriteCString(pkgName)) {
469         LNN_LOGE(LNN_EVENT, "write pkgName failed");
470         return SOFTBUS_IPC_ERR;
471     }
472     MessageParcel reply;
473     MessageOption option;
474     int32_t serverRet = remote->SendRequest(SERVER_REG_DATA_LEVEL_CHANGE_CB, data, reply, option);
475     if (serverRet != 0) {
476         LNN_LOGE(LNN_EVENT, "send request failed");
477         return serverRet;
478     }
479 
480     if (!reply.ReadInt32(serverRet)) {
481         LNN_LOGE(LNN_EVENT, "read serverRet failed");
482         return SOFTBUS_IPC_ERR;
483     }
484     return serverRet;
485 }
486 
UnregDataLevelChangeCb(const char * pkgName)487 int32_t BusCenterServerProxy::UnregDataLevelChangeCb(const char *pkgName)
488 {
489     if (pkgName == nullptr) {
490         return SOFTBUS_INVALID_PARAM;
491     }
492     sptr<IRemoteObject> remote = GetSystemAbility();
493     if (remote == nullptr) {
494         LNN_LOGE(LNN_EVENT, "remote is nullptr");
495         return SOFTBUS_IPC_ERR;
496     }
497     MessageParcel data;
498     if (!data.WriteInterfaceToken(GetDescriptor())) {
499         LNN_LOGE(LNN_EVENT, "write InterfaceToken failed");
500         return SOFTBUS_IPC_ERR;
501     }
502     if (!data.WriteCString(pkgName)) {
503         LNN_LOGE(LNN_EVENT, "write pkgName failed");
504         return SOFTBUS_IPC_ERR;
505     }
506     MessageParcel reply;
507     MessageOption option;
508     int32_t serverRet = remote->SendRequest(SERVER_UNREG_DATA_LEVEL_CHANGE_CB, data, reply, option);
509     if (serverRet != 0) {
510         LNN_LOGE(LNN_EVENT, "send request failed");
511         return serverRet;
512     }
513 
514     if (!reply.ReadInt32(serverRet)) {
515         LNN_LOGE(LNN_EVENT, "read serverRet failed");
516         return SOFTBUS_IPC_ERR;
517     }
518     return serverRet;
519 }
520 
SetDataLevel(const DataLevel * dataLevel)521 int32_t BusCenterServerProxy::SetDataLevel(const DataLevel *dataLevel)
522 {
523     if (dataLevel == nullptr) {
524         return SOFTBUS_INVALID_PARAM;
525     }
526     sptr<IRemoteObject> remote = GetSystemAbility();
527     if (remote == nullptr) {
528         LNN_LOGE(LNN_EVENT, "remote is nullptr");
529         return SOFTBUS_IPC_ERR;
530     }
531 
532     MessageParcel data;
533     if (!data.WriteInterfaceToken(GetDescriptor())) {
534         LNN_LOGE(LNN_EVENT, "write InterfaceToken failed");
535         return SOFTBUS_IPC_ERR;
536     }
537     if (!data.WriteRawData((void*)dataLevel, sizeof(DataLevel))) {
538         LNN_LOGE(LNN_EVENT, "write data level failed");
539         return SOFTBUS_IPC_ERR;
540     }
541     MessageParcel reply;
542     MessageOption option;
543     int32_t serverRet = remote->SendRequest(SERVER_SET_DATA_LEVEL, data, reply, option);
544     if (serverRet != 0) {
545         LNN_LOGE(LNN_EVENT, "send request failed");
546         return serverRet;
547     }
548 
549     if (!reply.ReadInt32(serverRet)) {
550         LNN_LOGE(LNN_EVENT, "read serverRet failed");
551         return SOFTBUS_IPC_ERR;
552     }
553     return serverRet;
554 }
555 
StartTimeSync(const char * pkgName,const char * targetNetworkId,int32_t accuracy,int32_t period)556 int32_t BusCenterServerProxy::StartTimeSync(const char *pkgName, const char *targetNetworkId, int32_t accuracy,
557     int32_t period)
558 {
559     if (pkgName == nullptr || targetNetworkId == nullptr) {
560         return SOFTBUS_INVALID_PARAM;
561     }
562     sptr<IRemoteObject> remote = GetSystemAbility();
563     if (remote == nullptr) {
564         LNN_LOGE(LNN_EVENT, "remote is nullptr");
565         return SOFTBUS_IPC_ERR;
566     }
567 
568     MessageParcel data;
569     if (!data.WriteInterfaceToken(GetDescriptor())) {
570         LNN_LOGE(LNN_EVENT, "write InterfaceToken failed");
571         return SOFTBUS_IPC_ERR;
572     }
573     if (!data.WriteCString(pkgName)) {
574         LNN_LOGE(LNN_EVENT, "write client name failed");
575         return SOFTBUS_IPC_ERR;
576     }
577 
578     if (!data.WriteCString(targetNetworkId)) {
579         LNN_LOGE(LNN_EVENT, "write networkId failed");
580         return SOFTBUS_IPC_ERR;
581     }
582     if (!data.WriteInt32(accuracy)) {
583         LNN_LOGE(LNN_EVENT, "write accuracy failed");
584         return SOFTBUS_IPC_ERR;
585     }
586     if (!data.WriteInt32(period)) {
587         LNN_LOGE(LNN_EVENT, "write period failed");
588         return SOFTBUS_IPC_ERR;
589     }
590     MessageParcel reply;
591     MessageOption option;
592     if (remote->SendRequest(SERVER_START_TIME_SYNC, data, reply, option) != 0) {
593         LNN_LOGE(LNN_EVENT, "send request failed");
594         return SOFTBUS_IPC_ERR;
595     }
596     int32_t serverRet = 0;
597     if (!reply.ReadInt32(serverRet)) {
598         LNN_LOGE(LNN_EVENT, "read serverRet failed");
599         return SOFTBUS_IPC_ERR;
600     }
601     return serverRet;
602 }
603 
StopTimeSync(const char * pkgName,const char * targetNetworkId)604 int32_t BusCenterServerProxy::StopTimeSync(const char *pkgName, const char *targetNetworkId)
605 {
606     if (pkgName == nullptr || targetNetworkId == nullptr) {
607         return SOFTBUS_ERR;
608     }
609     sptr<IRemoteObject> remote = GetSystemAbility();
610     if (remote == nullptr) {
611         LNN_LOGE(LNN_EVENT, "remote is nullptr");
612         return SOFTBUS_IPC_ERR;
613     }
614 
615     MessageParcel data;
616     if (!data.WriteInterfaceToken(GetDescriptor())) {
617         LNN_LOGE(LNN_EVENT, "write InterfaceToken failed");
618         return SOFTBUS_IPC_ERR;
619     }
620     if (!data.WriteCString(pkgName)) {
621         LNN_LOGE(LNN_EVENT, "write client name failed");
622         return SOFTBUS_IPC_ERR;
623     }
624 
625     if (!data.WriteCString(targetNetworkId)) {
626         LNN_LOGE(LNN_EVENT, "write networkId failed");
627         return SOFTBUS_IPC_ERR;
628     }
629     MessageParcel reply;
630     MessageOption option;
631     if (remote->SendRequest(SERVER_STOP_TIME_SYNC, data, reply, option) != 0) {
632         LNN_LOGE(LNN_EVENT, "send request failed");
633         return SOFTBUS_IPC_ERR;
634     }
635     int32_t serverRet = 0;
636     if (!reply.ReadInt32(serverRet)) {
637         LNN_LOGE(LNN_EVENT, "read serverRet failed");
638         return SOFTBUS_IPC_ERR;
639     }
640     return serverRet;
641 }
642 
PublishLNN(const char * pkgName,const PublishInfo * info)643 int32_t BusCenterServerProxy::PublishLNN(const char *pkgName, const PublishInfo *info)
644 {
645     if (pkgName == nullptr || info == nullptr) {
646         return SOFTBUS_INVALID_PARAM;
647     }
648     sptr<IRemoteObject> remote = GetSystemAbility();
649     if (remote == nullptr) {
650         LNN_LOGE(LNN_EVENT, "remote is nullptr");
651         return SOFTBUS_IPC_ERR;
652     }
653 
654     MessageParcel data;
655     if (!data.WriteInterfaceToken(GetDescriptor())) {
656         LNN_LOGE(LNN_EVENT, "write InterfaceToken failed");
657         return SOFTBUS_IPC_ERR;
658     }
659     if (!data.WriteCString(pkgName)) {
660         LNN_LOGE(LNN_EVENT, "write client name failed");
661         return SOFTBUS_IPC_ERR;
662     }
663     if (!data.WriteInt32(info->publishId) || !data.WriteInt32(info->mode) || !data.WriteInt32(info->medium) ||
664         !data.WriteInt32(info->freq) || !data.WriteCString(info->capability)) {
665         LNN_LOGE(LNN_EVENT, "write publish common info failed");
666         return SOFTBUS_IPC_ERR;
667     }
668     if (!data.WriteUint32(info->dataLen)) {
669         LNN_LOGE(LNN_EVENT, "write capabilityData length failed");
670         return SOFTBUS_IPC_ERR;
671     }
672     if (info->dataLen != 0 && !data.WriteCString((const char *)info->capabilityData)) {
673         LNN_LOGE(LNN_EVENT, "write capabilityData failed");
674         return SOFTBUS_IPC_ERR;
675     }
676     if (!data.WriteBool(info->ranging)) {
677         LNN_LOGE(LNN_EVENT, "write ranging failed");
678         return SOFTBUS_IPC_ERR;
679     }
680     MessageParcel reply;
681     MessageOption option;
682     if (remote->SendRequest(SERVER_PUBLISH_LNN, data, reply, option) != 0) {
683         LNN_LOGE(LNN_EVENT, "send request failed");
684         return SOFTBUS_IPC_ERR;
685     }
686     int32_t serverRet;
687     if (!reply.ReadInt32(serverRet)) {
688         LNN_LOGE(LNN_EVENT, "read serverRet failed");
689         return SOFTBUS_IPC_ERR;
690     }
691     return serverRet;
692 }
693 
StopPublishLNN(const char * pkgName,int32_t publishId)694 int32_t BusCenterServerProxy::StopPublishLNN(const char *pkgName, int32_t publishId)
695 {
696     if (pkgName == nullptr) {
697         return SOFTBUS_INVALID_PARAM;
698     }
699     sptr<IRemoteObject> remote = GetSystemAbility();
700     if (remote == nullptr) {
701         LNN_LOGE(LNN_EVENT, "remote is nullptr");
702         return SOFTBUS_IPC_ERR;
703     }
704 
705     MessageParcel data;
706     if (!data.WriteInterfaceToken(GetDescriptor())) {
707         LNN_LOGE(LNN_EVENT, "write InterfaceToken failed");
708         return SOFTBUS_IPC_ERR;
709     }
710     if (!data.WriteCString(pkgName)) {
711         LNN_LOGE(LNN_EVENT, "write client name failed");
712         return SOFTBUS_IPC_ERR;
713     }
714     if (!data.WriteInt32(publishId)) {
715         LNN_LOGE(LNN_EVENT, "write publishId failed");
716         return SOFTBUS_IPC_ERR;
717     }
718     MessageParcel reply;
719     MessageOption option;
720     if (remote->SendRequest(SERVER_STOP_PUBLISH_LNN, data, reply, option) != 0) {
721         LNN_LOGE(LNN_EVENT, "send request failed");
722         return SOFTBUS_IPC_ERR;
723     }
724     int32_t serverRet = 0;
725     if (!reply.ReadInt32(serverRet)) {
726         LNN_LOGE(LNN_EVENT, "read serverRet failed");
727         return SOFTBUS_IPC_ERR;
728     }
729     return serverRet;
730 }
731 
RefreshLNN(const char * pkgName,const SubscribeInfo * info)732 int32_t BusCenterServerProxy::RefreshLNN(const char *pkgName, const SubscribeInfo *info)
733 {
734     if (pkgName == nullptr || info == nullptr) {
735         return SOFTBUS_INVALID_PARAM;
736     }
737     sptr<IRemoteObject> remote = GetSystemAbility();
738     if (remote == nullptr) {
739         LNN_LOGE(LNN_EVENT, "remote is nullptr");
740         return SOFTBUS_IPC_ERR;
741     }
742     MessageParcel data;
743     if (!data.WriteInterfaceToken(GetDescriptor())) {
744         LNN_LOGE(LNN_EVENT, "write InterfaceToken failed");
745         return SOFTBUS_IPC_ERR;
746     }
747     if (!data.WriteCString(pkgName)) {
748         LNN_LOGE(LNN_EVENT, "write client name failed");
749         return SOFTBUS_IPC_ERR;
750     }
751     if (!data.WriteInt32(info->subscribeId) || !data.WriteInt32(info->mode) || !data.WriteInt32(info->medium) ||
752         !data.WriteInt32(info->freq)) {
753         LNN_LOGE(LNN_EVENT, "write subscribe common info failed");
754         return SOFTBUS_IPC_ERR;
755     }
756     if (!data.WriteBool(info->isSameAccount) || !data.WriteBool(info->isWakeRemote) ||
757         !data.WriteCString(info->capability)) {
758         LNN_LOGE(LNN_EVENT, "write flag and capability failed");
759         return SOFTBUS_IPC_ERR;
760     }
761     if (!data.WriteUint32(info->dataLen)) {
762         LNN_LOGE(LNN_EVENT, "write capabilityData length failed");
763         return SOFTBUS_IPC_ERR;
764     }
765     if (info->dataLen != 0 && !data.WriteCString((const char *)info->capabilityData)) {
766         LNN_LOGE(LNN_EVENT, "write capabilityData failed");
767         return SOFTBUS_IPC_ERR;
768     }
769     MessageParcel reply;
770     MessageOption option;
771     if (remote->SendRequest(SERVER_REFRESH_LNN, data, reply, option) != 0) {
772         LNN_LOGE(LNN_EVENT, "send request failed");
773         return SOFTBUS_IPC_ERR;
774     }
775     int32_t serverRet;
776     if (!reply.ReadInt32(serverRet)) {
777         LNN_LOGE(LNN_EVENT, "read serverRet failed");
778         return SOFTBUS_IPC_ERR;
779     }
780     return serverRet;
781 }
782 
StopRefreshLNN(const char * pkgName,int32_t refreshId)783 int32_t BusCenterServerProxy::StopRefreshLNN(const char *pkgName, int32_t refreshId)
784 {
785     if (pkgName == nullptr) {
786         return SOFTBUS_INVALID_PARAM;
787     }
788     sptr<IRemoteObject> remote = GetSystemAbility();
789     if (remote == nullptr) {
790         LNN_LOGE(LNN_EVENT, "remote is nullptr");
791         return SOFTBUS_IPC_ERR;
792     }
793 
794     MessageParcel data;
795     if (!data.WriteInterfaceToken(GetDescriptor())) {
796         LNN_LOGE(LNN_EVENT, "write InterfaceToken failed");
797         return SOFTBUS_IPC_ERR;
798     }
799     if (!data.WriteCString(pkgName)) {
800         LNN_LOGE(LNN_EVENT, "write client name failed");
801         return SOFTBUS_IPC_ERR;
802     }
803     if (!data.WriteInt32(refreshId)) {
804         LNN_LOGE(LNN_EVENT, "write refreshId failed");
805         return SOFTBUS_IPC_ERR;
806     }
807     MessageParcel reply;
808     MessageOption option;
809     if (remote->SendRequest(SERVER_STOP_REFRESH_LNN, data, reply, option) != 0) {
810         LNN_LOGE(LNN_EVENT, "send request failed");
811         return SOFTBUS_IPC_ERR;
812     }
813     int32_t serverRet = 0;
814     if (!reply.ReadInt32(serverRet)) {
815         LNN_LOGE(LNN_EVENT, "read serverRet failed");
816         return SOFTBUS_IPC_ERR;
817     }
818     return serverRet;
819 }
820 
ActiveMetaNode(const MetaNodeConfigInfo * info,char * metaNodeId)821 int32_t BusCenterServerProxy::ActiveMetaNode(const MetaNodeConfigInfo *info, char *metaNodeId)
822 {
823     sptr<IRemoteObject> remote = GetSystemAbility();
824     if (remote == nullptr) {
825         LNN_LOGE(LNN_EVENT, "remote is nullptr");
826         return SOFTBUS_IPC_ERR;
827     }
828 
829     MessageParcel data;
830     if (!data.WriteInterfaceToken(GetDescriptor())) {
831         LNN_LOGE(LNN_EVENT, "write InterfaceToken failed");
832         return SOFTBUS_IPC_ERR;
833     }
834     if (!data.WriteRawData(info, sizeof(MetaNodeConfigInfo))) {
835         LNN_LOGE(LNN_EVENT, "write meta node config failed");
836         return SOFTBUS_IPC_ERR;
837     }
838     MessageParcel reply;
839     MessageOption option;
840     if (remote->SendRequest(SERVER_ACTIVE_META_NODE, data, reply, option) != 0) {
841         LNN_LOGE(LNN_EVENT, "send request failed");
842         return SOFTBUS_IPC_ERR;
843     }
844     char *retBuf = const_cast<char *>(reply.ReadCString());
845     if (retBuf == nullptr) {
846         LNN_LOGE(LNN_EVENT, "read meta node id failed");
847         return SOFTBUS_IPC_ERR;
848     }
849     if (strncpy_s(metaNodeId, NETWORK_ID_BUF_LEN, retBuf, strlen(retBuf)) != EOK) {
850         LNN_LOGE(LNN_EVENT, "copy meta node id failed");
851         return SOFTBUS_ERR;
852     }
853     return SOFTBUS_OK;
854 }
855 
DeactiveMetaNode(const char * metaNodeId)856 int32_t BusCenterServerProxy::DeactiveMetaNode(const char *metaNodeId)
857 {
858     if (metaNodeId == nullptr) {
859         LNN_LOGE(LNN_EVENT, "params are nullptr");
860         return SOFTBUS_INVALID_PARAM;
861     }
862     sptr<IRemoteObject> remote = GetSystemAbility();
863     if (remote == nullptr) {
864         LNN_LOGE(LNN_EVENT, "remote is nullptr");
865         return SOFTBUS_IPC_ERR;
866     }
867 
868     MessageParcel data;
869     if (!data.WriteInterfaceToken(GetDescriptor())) {
870         LNN_LOGE(LNN_EVENT, "write InterfaceToken failed");
871         return SOFTBUS_IPC_ERR;
872     }
873     if (!data.WriteCString(metaNodeId)) {
874         LNN_LOGE(LNN_EVENT, "write meta node id failed");
875         return SOFTBUS_IPC_ERR;
876     }
877     MessageParcel reply;
878     MessageOption option;
879     if (remote->SendRequest(SERVER_DEACTIVE_META_NODE, data, reply, option) != 0) {
880         LNN_LOGE(LNN_EVENT, "send request failed");
881         return SOFTBUS_IPC_ERR;
882     }
883     return SOFTBUS_OK;
884 }
885 
GetAllMetaNodeInfo(MetaNodeInfo * infos,int32_t * infoNum)886 int32_t BusCenterServerProxy::GetAllMetaNodeInfo(MetaNodeInfo *infos, int32_t *infoNum)
887 {
888     sptr<IRemoteObject> remote = GetSystemAbility();
889     if (remote == nullptr) {
890         LNN_LOGE(LNN_EVENT, "remote is nullptr");
891         return SOFTBUS_IPC_ERR;
892     }
893 
894     MessageParcel data;
895     if (!data.WriteInterfaceToken(GetDescriptor())) {
896         LNN_LOGE(LNN_EVENT, "write InterfaceToken failed");
897         return SOFTBUS_IPC_ERR;
898     }
899     if (!data.WriteInt32(*infoNum)) {
900         LNN_LOGE(LNN_EVENT, "write infoNum failed");
901         return SOFTBUS_IPC_ERR;
902     }
903     MessageParcel reply;
904     MessageOption option;
905     if (remote->SendRequest(SERVER_GET_ALL_META_NODE_INFO, data, reply, option) != 0) {
906         LNN_LOGE(LNN_EVENT, "send request failed");
907         return SOFTBUS_IPC_ERR;
908     }
909     int32_t retInfoNum;
910     if (!reply.ReadInt32(retInfoNum)) {
911         LNN_LOGE(LNN_EVENT, "read infoNum failed");
912         return SOFTBUS_IPC_ERR;
913     }
914     if (retInfoNum > 0) {
915         char *retBuf = reinterpret_cast<char *>(const_cast<void *>(
916             reply.ReadRawData(retInfoNum * sizeof(MetaNodeInfo))));
917         if (retBuf == nullptr) {
918             LNN_LOGE(LNN_EVENT, "read meta node failed");
919             return SOFTBUS_IPC_ERR;
920         }
921         if (memcpy_s(infos, *infoNum * sizeof(MetaNodeInfo), retBuf, retInfoNum * sizeof(MetaNodeInfo)) != EOK) {
922             LNN_LOGE(LNN_EVENT, "copy meta node info failed");
923             return SOFTBUS_MEM_ERR;
924         }
925     }
926     *infoNum = retInfoNum;
927     return SOFTBUS_OK;
928 }
929 
ShiftLNNGear(const char * pkgName,const char * callerId,const char * targetNetworkId,const GearMode * mode)930 int32_t BusCenterServerProxy::ShiftLNNGear(const char *pkgName, const char *callerId, const char *targetNetworkId,
931     const GearMode *mode)
932 {
933     if (pkgName == nullptr || callerId == nullptr || mode == nullptr) {
934         LNN_LOGE(LNN_EVENT, "params are nullptr");
935         return SOFTBUS_INVALID_PARAM;
936     }
937     sptr<IRemoteObject> remote = GetSystemAbility();
938     if (remote == nullptr) {
939         LNN_LOGE(LNN_EVENT, "remote is nullptr");
940         return SOFTBUS_ERR;
941     }
942 
943     bool targetNetworkIdIsNull = targetNetworkId == NULL ? true : false;
944     MessageParcel data;
945     if (!data.WriteInterfaceToken(GetDescriptor())) {
946         LNN_LOGE(LNN_EVENT, "write InterfaceToken failed");
947         return SOFTBUS_ERR;
948     }
949     if (!data.WriteCString(pkgName)) {
950         LNN_LOGE(LNN_EVENT, "write pkg name failed");
951         return SOFTBUS_ERR;
952     }
953     if (!data.WriteCString(callerId)) {
954         LNN_LOGE(LNN_EVENT, "write callerId failed");
955         return SOFTBUS_ERR;
956     }
957     if (!targetNetworkIdIsNull && (!data.WriteBool(targetNetworkIdIsNull) || !data.WriteCString(targetNetworkId))) {
958         LNN_LOGE(LNN_EVENT, "write target networkid failed");
959         return SOFTBUS_ERR;
960     } else if (targetNetworkIdIsNull && !data.WriteBool(targetNetworkIdIsNull)) {
961         LNN_LOGE(LNN_EVENT, "write null target networkid failed");
962         return SOFTBUS_ERR;
963     }
964     if (!data.WriteRawData(mode, sizeof(GearMode))) {
965         LNN_LOGE(LNN_EVENT, "write gear node config failed");
966         return SOFTBUS_ERR;
967     }
968     MessageParcel reply;
969     MessageOption option;
970     if (remote->SendRequest(SERVER_SHIFT_LNN_GEAR, data, reply, option) != 0) {
971         LNN_LOGE(LNN_EVENT, "send request failed");
972         return SOFTBUS_ERR;
973     }
974     int32_t serverRet = 0;
975     if (!reply.ReadInt32(serverRet)) {
976         LNN_LOGE(LNN_EVENT, "read serverRet failed");
977         return SOFTBUS_ERR;
978     }
979     return serverRet;
980 }
981 
GetBusCenterExObj(sptr<IRemoteObject> & object)982 int32_t BusCenterServerProxy::GetBusCenterExObj(sptr<IRemoteObject> &object)
983 {
984     sptr<IRemoteObject> remote = GetSystemAbility();
985     if (remote == nullptr) {
986         LNN_LOGE(LNN_EVENT, "remote is null");
987         return SOFTBUS_ERR;
988     }
989     MessageParcel data;
990     if (!data.WriteInterfaceToken(GetDescriptor())) {
991         LNN_LOGE(LNN_EVENT, "GetBusCenterExObj write InterfaceToken failed!");
992         return SOFTBUS_ERR;
993     }
994     MessageParcel reply;
995     MessageOption option;
996     int32_t ret = remote->SendRequest(SERVER_GET_BUS_CENTER_EX_OBJ, data, reply, option);
997     if (ret != ERR_NONE) {
998         LNN_LOGE(LNN_EVENT, "send request failed, ret=%{public}d", ret);
999         return SOFTBUS_ERR;
1000     }
1001     if (!reply.ReadInt32(ret)) {
1002         LNN_LOGE(LNN_EVENT, "GetBusCenterExObj send ret failed");
1003         return SOFTBUS_ERR;
1004     }
1005     if (ret == SOFTBUS_OK) {
1006         object = reply.ReadRemoteObject();
1007     }
1008     return ret;
1009 }
1010 
EvaluateQos(const char * peerNetworkId,TransDataType dataType,const QosTV * qos,uint32_t qosCount)1011 int32_t BusCenterServerProxy::EvaluateQos(const char *peerNetworkId, TransDataType dataType, const QosTV *qos,
1012     uint32_t qosCount)
1013 {
1014     (void)peerNetworkId;
1015     (void)dataType;
1016     (void)qos;
1017     (void)qosCount;
1018     return SOFTBUS_OK;
1019 }
1020 } // namespace OHOS