1 /*
2  * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "bus_center_server_stub.h"
17 
18 #include <stdint.h>
19 
20 #include "ipc_skeleton.h"
21 #include "lnn_bus_center_ipc.h"
22 #include "lnn_log.h"
23 #include "securec.h"
24 #include "softbus_adapter_mem.h"
25 #include "softbus_bus_center.h"
26 #include "softbus_def.h"
27 #include "softbus_errcode.h"
28 #include "softbus_permission.h"
29 
CheckPermission(const char * pkgName,int32_t uid)30 static int32_t CheckPermission(const char *pkgName, int32_t uid)
31 {
32     if (pkgName == NULL) {
33         LNN_LOGE(LNN_STATE, "pkgName is null");
34         return SOFTBUS_ERR;
35     }
36     if (!CheckBusCenterPermission(uid, pkgName)) {
37         LNN_LOGE(LNN_STATE, "no permission");
38         return SOFTBUS_PERMISSION_DENIED;
39     }
40     return SOFTBUS_OK;
41 }
42 
ServerJoinLNN(IpcIo * req,IpcIo * reply)43 int32_t ServerJoinLNN(IpcIo *req, IpcIo *reply)
44 {
45     LNN_LOGD(LNN_STATE, "ipc server pop");
46     if (req == NULL || reply == NULL) {
47         LNN_LOGE(LNN_STATE, "invalid param");
48         return SOFTBUS_INVALID_PARAM;
49     }
50     size_t len;
51     const char *pkgName = (const char *)ReadString(req, &len);
52     if (pkgName == NULL || len >= PKG_NAME_SIZE_MAX) {
53         LNN_LOGE(LNN_STATE, "read pkgName failed");
54         return SOFTBUS_INVALID_PARAM;
55     }
56     uint32_t addrTypeLen;
57     ReadUint32(req, &addrTypeLen);
58     if (addrTypeLen != sizeof(ConnectionAddr)) {
59         LNN_LOGE(LNN_STATE, "read addrTypeLen=%{public}d failed", addrTypeLen);
60         return SOFTBUS_ERR;
61     }
62     void *addr = (void *)ReadBuffer(req, addrTypeLen);
63     if (addr == NULL) {
64         LNN_LOGE(LNN_STATE, "read addr is null");
65         return SOFTBUS_IPC_ERR;
66     }
67     int32_t callingUid = GetCallingUid();
68     if (CheckPermission(pkgName, callingUid) != SOFTBUS_OK) {
69         LNN_LOGE(LNN_STATE, "no permission");
70         return SOFTBUS_PERMISSION_DENIED;
71     }
72     int32_t ret = LnnIpcServerJoin(pkgName, 0, addr, addrTypeLen);
73     if (ret != SOFTBUS_OK) {
74         LNN_LOGE(LNN_STATE, "LnnIpcServerJoin failed");
75         return SOFTBUS_ERR;
76     }
77     return SOFTBUS_OK;
78 }
79 
ServerJoinMetaNode(IpcIo * req,IpcIo * reply)80 int32_t ServerJoinMetaNode(IpcIo *req, IpcIo *reply)
81 {
82     (void)req;
83     (void)reply;
84     return SOFTBUS_OK;
85 }
86 
ServerLeaveLNN(IpcIo * req,IpcIo * reply)87 int32_t ServerLeaveLNN(IpcIo *req, IpcIo *reply)
88 {
89     LNN_LOGI(LNN_STATE, "ipc server pop");
90     size_t len;
91     const char *pkgName = (const char *)ReadString(req, &len);
92     if (pkgName == NULL || len >= PKG_NAME_SIZE_MAX) {
93         LNN_LOGE(LNN_STATE, "read pkgName failed");
94         return SOFTBUS_INVALID_PARAM;
95     }
96     const char *networkId = (const char *)ReadString(req, &len);
97     if (networkId == NULL || len >= NETWORK_ID_BUF_LEN) {
98         LNN_LOGE(LNN_STATE, "read networkId failed");
99         return SOFTBUS_ERR;
100     }
101     int32_t callingUid = GetCallingUid();
102     if (CheckPermission(pkgName, callingUid) != SOFTBUS_OK) {
103         LNN_LOGE(LNN_STATE, "no permission");
104         return SOFTBUS_PERMISSION_DENIED;
105     }
106     int32_t ret = LnnIpcServerLeave(pkgName, 0, networkId);
107     if (ret != SOFTBUS_OK) {
108         LNN_LOGE(LNN_STATE, "LnnIpcServerLeave failed");
109         return SOFTBUS_ERR;
110     }
111     return SOFTBUS_OK;
112 }
113 
ServerLeaveMetaNode(IpcIo * req,IpcIo * reply)114 int32_t ServerLeaveMetaNode(IpcIo *req, IpcIo *reply)
115 {
116     (void)req;
117     (void)reply;
118     return SOFTBUS_OK;
119 }
120 
ServerGetAllOnlineNodeInfo(IpcIo * req,IpcIo * reply)121 int32_t ServerGetAllOnlineNodeInfo(IpcIo *req, IpcIo *reply)
122 {
123     LNN_LOGI(LNN_STATE, "ipc server pop");
124     void *nodeInfo = NULL;
125     int32_t infoNum = 0;
126     size_t len;
127     const char *pkgName = (const char *)ReadString(req, &len);
128     if (pkgName == NULL || len >= PKG_NAME_SIZE_MAX) {
129         LNN_LOGE(LNN_STATE, "read pkgName failed");
130         return SOFTBUS_INVALID_PARAM;
131     }
132     uint32_t infoTypeLen;
133     ReadUint32(req, &infoTypeLen);
134     int32_t callingUid = GetCallingUid();
135     if (CheckPermission(pkgName, callingUid) != SOFTBUS_OK) {
136         LNN_LOGE(LNN_STATE, "no permission");
137         WriteInt32(reply, SOFTBUS_PERMISSION_DENIED);
138         return SOFTBUS_PERMISSION_DENIED;
139     }
140     int32_t ret = LnnIpcGetAllOnlineNodeInfo(pkgName, &nodeInfo, infoTypeLen, &infoNum);
141     if (ret != SOFTBUS_OK) {
142         LNN_LOGE(LNN_STATE, "get info failed");
143         WriteInt32(reply, SOFTBUS_ERR);
144         return SOFTBUS_ERR;
145     }
146     if (infoNum < 0 || (infoNum > 0 && nodeInfo == NULL)) {
147         LNN_LOGE(LNN_STATE, "node info is invalid");
148         if (!(WriteInt32(reply, SOFTBUS_ERR))) {
149             LNN_LOGE(LNN_STATE, "write reply failed!");
150             SoftBusFree(nodeInfo);
151             return SOFTBUS_ERR;
152         }
153     }
154     if (!(WriteInt32(reply, infoNum))) {
155         LNN_LOGE(LNN_STATE, "write infoNum failed!");
156         SoftBusFree(nodeInfo);
157         return SOFTBUS_ERR;
158     }
159     if (infoNum > 0) {
160         WriteUint32(reply, infoTypeLen * infoNum);
161         WriteBuffer(reply, nodeInfo, infoTypeLen * infoNum);
162         SoftBusFree(nodeInfo);
163     }
164     return SOFTBUS_OK;
165 }
166 
ServerGetLocalDeviceInfo(IpcIo * req,IpcIo * reply)167 int32_t ServerGetLocalDeviceInfo(IpcIo *req, IpcIo *reply)
168 {
169     LNN_LOGD(LNN_STATE, "ipc server pop");
170     void *nodeInfo = NULL;
171     size_t len;
172     const char *pkgName = (const char *)ReadString(req, &len);
173     if (pkgName == NULL || len >= PKG_NAME_SIZE_MAX) {
174         LNN_LOGE(LNN_STATE, "read pkgName failed");
175         return SOFTBUS_INVALID_PARAM;
176     }
177     int32_t callingUid = GetCallingUid();
178     if (CheckPermission(pkgName, callingUid) != SOFTBUS_OK) {
179         LNN_LOGE(LNN_STATE, "no permission");
180         return SOFTBUS_PERMISSION_DENIED;
181     }
182     uint32_t infoTypeLen;
183     ReadUint32(req, &infoTypeLen);
184     if (infoTypeLen != sizeof(NodeBasicInfo)) {
185         LNN_LOGE(LNN_STATE, "read infoTypeLen failed, infoTypeLen=%{public}u", infoTypeLen);
186         return SOFTBUS_INVALID_PARAM;
187     }
188     nodeInfo = SoftBusCalloc(infoTypeLen);
189     if (nodeInfo == NULL) {
190         LNN_LOGE(LNN_STATE, "malloc info type length failed");
191         return SOFTBUS_MEM_ERR;
192     }
193     int32_t ret = LnnIpcGetLocalDeviceInfo(pkgName, nodeInfo, infoTypeLen);
194     if (ret != SOFTBUS_OK) {
195         LNN_LOGE(LNN_STATE, "get local info failed");
196         SoftBusFree(nodeInfo);
197         return SOFTBUS_ERR;
198     }
199     if (!(WriteUint32(reply, infoTypeLen))) {
200         LNN_LOGE(LNN_STATE, "write reply failed!");
201         SoftBusFree(nodeInfo);
202         return SOFTBUS_ERR;
203     }
204     WriteBuffer(reply, nodeInfo, infoTypeLen);
205     SoftBusFree(nodeInfo);
206     return SOFTBUS_OK;
207 }
208 
ServerRecoverGetNodeKeyInfo(void * buf,IpcIo * reply,int32_t infoLen)209 static int32_t ServerRecoverGetNodeKeyInfo(void *buf, IpcIo *reply, int32_t infoLen)
210 {
211     if (!(WriteInt32(reply, infoLen))) {
212         LNN_LOGE(LNN_STATE, "write reply failed!");
213         return SOFTBUS_ERR;
214     }
215     WriteBuffer(reply, buf, infoLen);
216     return SOFTBUS_OK;
217 }
218 
ServerGetNodeKeyInfo(IpcIo * req,IpcIo * reply)219 int32_t ServerGetNodeKeyInfo(IpcIo *req, IpcIo *reply)
220 {
221     LNN_LOGD(LNN_STATE, "ipc server pop");
222     size_t length;
223     const char *pkgName = (const char *)ReadString(req, &length);
224     if (pkgName == NULL || length >= PKG_NAME_SIZE_MAX) {
225         LNN_LOGE(LNN_STATE, "read pkgName failed");
226         return SOFTBUS_INVALID_PARAM;
227     }
228     int32_t callingUid = GetCallingUid();
229     if (CheckPermission(pkgName, callingUid) != SOFTBUS_OK) {
230         LNN_LOGE(LNN_STATE, "no permission");
231         return SOFTBUS_PERMISSION_DENIED;
232     }
233     const char *networkId = (const char *)ReadString(req, &length);
234     if (networkId == NULL || length >= NETWORK_ID_BUF_LEN) {
235         LNN_LOGE(LNN_STATE, "read networkId failed");
236         return SOFTBUS_ERR;
237     }
238     int32_t key;
239     ReadInt32(req, &key);
240     int32_t infoLen  = LnnIpcGetNodeKeyInfoLen(key);
241     if (infoLen == SOFTBUS_ERR) {
242         LNN_LOGE(LNN_STATE, "get infoLen failed");
243         return SOFTBUS_ERR;
244     }
245     uint32_t len;
246     ReadUint32(req, &len);
247     if (len < (uint32_t)infoLen) {
248         LNN_LOGE(LNN_STATE, "read len is invalid param, len=%{public}u, infoLen=%{public}d", len,
249             infoLen);
250         return SOFTBUS_ERR;
251     }
252     void *buf = SoftBusCalloc(infoLen);
253     if (buf == NULL) {
254         LNN_LOGE(LNN_STATE, "malloc buffer failed");
255         return SOFTBUS_MEM_ERR;
256     }
257     int32_t ret = LnnIpcGetNodeKeyInfo(pkgName, networkId, key, (unsigned char *)buf, infoLen);
258     if (ret != SOFTBUS_OK) {
259         LNN_LOGE(LNN_STATE, "get local info failed");
260         SoftBusFree(buf);
261         return SOFTBUS_ERR;
262     }
263     ret = ServerRecoverGetNodeKeyInfo(buf, reply, infoLen);
264     SoftBusFree(buf);
265     return ret;
266 }
267 
ServerSetNodeDataChangeFlag(IpcIo * req,IpcIo * reply)268 int32_t ServerSetNodeDataChangeFlag(IpcIo *req, IpcIo *reply)
269 {
270     LNN_LOGD(LNN_STATE, "ipc server pop");
271     size_t length;
272     const char *pkgName = (const char *)ReadString(req, &length);
273     if (pkgName == NULL || length >= PKG_NAME_SIZE_MAX) {
274         LNN_LOGE(LNN_STATE, "read pkgName failed");
275         return SOFTBUS_INVALID_PARAM;
276     }
277     const char *networkId = (const char *)ReadString(req, &length);
278     if (networkId == NULL || length >= NETWORK_ID_BUF_LEN) {
279         LNN_LOGE(LNN_STATE, "read networkId failed");
280         return SOFTBUS_ERR;
281     }
282     int16_t dataChangeFlag;
283     ReadInt16(req, &dataChangeFlag);
284     int32_t callingUid = GetCallingUid();
285     if (CheckPermission(pkgName, callingUid) != SOFTBUS_OK) {
286         LNN_LOGE(LNN_STATE, "no permission");
287         return SOFTBUS_PERMISSION_DENIED;
288     }
289     int32_t ret = LnnIpcSetNodeDataChangeFlag(pkgName, networkId, dataChangeFlag);
290     if (ret != SOFTBUS_OK) {
291         LNN_LOGE(LNN_STATE, "get local info failed");
292         return SOFTBUS_ERR;
293     }
294     return SOFTBUS_OK;
295 }
296 
ServerRegDataLevelChangeCb(IpcIo * req,IpcIo * reply)297 int32_t ServerRegDataLevelChangeCb(IpcIo *req, IpcIo *reply)
298 {
299     (void)req;
300     (void)reply;
301     return SOFTBUS_FUNC_NOT_SUPPORT;
302 }
303 
ServerUnregDataLevelChangeCb(IpcIo * req,IpcIo * reply)304 int32_t ServerUnregDataLevelChangeCb(IpcIo *req, IpcIo *reply)
305 {
306     (void)req;
307     (void)reply;
308     return SOFTBUS_FUNC_NOT_SUPPORT;
309 }
310 
ServerSetDataLevel(IpcIo * req,IpcIo * reply)311 int32_t ServerSetDataLevel(IpcIo *req, IpcIo *reply)
312 {
313     (void)req;
314     (void)reply;
315     return SOFTBUS_FUNC_NOT_SUPPORT;
316 }
317 
ServerStartTimeSync(IpcIo * req,IpcIo * reply)318 int32_t ServerStartTimeSync(IpcIo *req, IpcIo *reply)
319 {
320     LNN_LOGD(LNN_STATE, "ipc server pop");
321     size_t length;
322     const char *pkgName = (const char *)ReadString(req, &length);
323     if (pkgName == NULL || length >= PKG_NAME_SIZE_MAX) {
324         LNN_LOGE(LNN_STATE, "read pkgName failed");
325         return SOFTBUS_INVALID_PARAM;
326     }
327     const char *targetNetworkId = (const char *)ReadString(req, &length);
328     if (targetNetworkId == NULL || length >= NETWORK_ID_BUF_LEN) {
329         LNN_LOGE(LNN_STATE, "read targetNetworkId failed");
330         return SOFTBUS_ERR;
331     }
332     int32_t accuracy;
333     int32_t period;
334     ReadInt32(req, &accuracy);
335     ReadInt32(req, &period);
336     int32_t callingUid = GetCallingUid();
337     if (CheckPermission(pkgName, callingUid) != SOFTBUS_OK) {
338         LNN_LOGE(LNN_STATE, "no permission");
339         return SOFTBUS_PERMISSION_DENIED;
340     }
341     int32_t ret = LnnIpcStartTimeSync(pkgName, 0, targetNetworkId, accuracy, period);
342     if (ret != SOFTBUS_OK) {
343         LNN_LOGE(LNN_STATE, "start time sync failed");
344         return SOFTBUS_ERR;
345     }
346     return SOFTBUS_OK;
347 }
348 
ServerStopTimeSync(IpcIo * req,IpcIo * reply)349 int32_t ServerStopTimeSync(IpcIo *req, IpcIo *reply)
350 {
351     LNN_LOGI(LNN_STATE, "ipc server pop");
352     size_t length;
353     const char *pkgName = (const char *)ReadString(req, &length);
354     if (pkgName == NULL || length >= PKG_NAME_SIZE_MAX) {
355         LNN_LOGE(LNN_STATE, "read pkgName failed");
356         return SOFTBUS_INVALID_PARAM;
357     }
358     const char *targetNetworkId = (const char *)ReadString(req, &length);
359     if (targetNetworkId == NULL || length >= NETWORK_ID_BUF_LEN) {
360         LNN_LOGE(LNN_STATE, "read targetNetworkId failed");
361         return SOFTBUS_ERR;
362     }
363     int32_t callingUid = GetCallingUid();
364     if (CheckPermission(pkgName, callingUid) != SOFTBUS_OK) {
365         LNN_LOGE(LNN_STATE, "no permission");
366         return SOFTBUS_PERMISSION_DENIED;
367     }
368     int32_t ret = LnnIpcStopTimeSync(pkgName, targetNetworkId, 0);
369     if (ret != SOFTBUS_OK) {
370         LNN_LOGE(LNN_STATE, "start time sync failed");
371         return SOFTBUS_ERR;
372     }
373     return SOFTBUS_OK;
374 }
375 
ServerRecoverPublishLNN(const char * pkgName,PublishInfo * info,IpcIo * reply)376 static int32_t ServerRecoverPublishLNN(const char *pkgName, PublishInfo* info, IpcIo *reply)
377 {
378     int32_t ret = LnnIpcPublishLNN(pkgName, info);
379     WriteInt32(reply, ret);
380     if (ret != SOFTBUS_OK) {
381         LNN_LOGE(LNN_STATE, "LnnIpcPublishLNN failed");
382         return SOFTBUS_ERR;
383     }
384     return SOFTBUS_OK;
385 }
386 
ServerPublishLNN(IpcIo * req,IpcIo * reply)387 int32_t ServerPublishLNN(IpcIo *req, IpcIo *reply)
388 {
389     LNN_LOGD(LNN_STATE, "ipc server pop");
390     if (req == NULL || reply == NULL) {
391         LNN_LOGE(LNN_STATE, "invalid param.");
392         return SOFTBUS_INVALID_PARAM;
393     }
394     size_t len;
395     const char *pkgName = (const char *)ReadString(req, &len);
396     if (pkgName == NULL || len >= PKG_NAME_SIZE_MAX) {
397         LNN_LOGE(LNN_STATE, "read pkgName failed");
398         return SOFTBUS_INVALID_PARAM;
399     }
400     int32_t callingUid = GetCallingUid();
401     if (CheckPermission(pkgName, callingUid) != SOFTBUS_OK) {
402         LNN_LOGE(LNN_STATE, "no permission");
403         return SOFTBUS_PERMISSION_DENIED;
404     }
405     PublishInfo info;
406     (void)memset_s(&info, sizeof(PublishInfo), 0, sizeof(PublishInfo));
407     ReadInt32(req, &info.publishId);
408     int32_t mode, medium, freq;
409     ReadInt32(req, &mode);
410     ReadInt32(req, &medium);
411     ReadInt32(req, &freq);
412     info.mode = (DiscoverMode)mode;
413     info.medium = (ExchangeMedium)medium;
414     info.freq = (ExchangeFreq)freq;
415     info.capability = (const char *)ReadString(req, &len);
416     if (info.capability == NULL) {
417         LNN_LOGE(LNN_STATE, "read capability is null");
418         return SOFTBUS_IPC_ERR;
419     }
420     ReadUint32(req, &info.dataLen);
421     if (info.dataLen > 0 && info.dataLen < MAX_CAPABILITYDATA_LEN) {
422         info.capabilityData = (unsigned char *)ReadString(req, &len);
423         if (info.capabilityData == NULL) {
424             LNN_LOGE(LNN_STATE, "read capabilityData is null");
425             return SOFTBUS_IPC_ERR;
426         }
427     } else {
428         info.capabilityData = NULL;
429         info.dataLen = 0;
430     }
431     ReadBool(req, &info.ranging);
432     return ServerRecoverPublishLNN(pkgName, &info, reply);
433 }
434 
ServerStopPublishLNN(IpcIo * req,IpcIo * reply)435 int32_t ServerStopPublishLNN(IpcIo *req, IpcIo *reply)
436 {
437     LNN_LOGD(LNN_STATE, "ipc server pop");
438     if (req == NULL || reply == NULL) {
439         LNN_LOGE(LNN_STATE, "invalid param.");
440         return SOFTBUS_INVALID_PARAM;
441     }
442     size_t len;
443     const char *pkgName = (const char *)ReadString(req, &len);
444     if (pkgName == NULL || len >= PKG_NAME_SIZE_MAX) {
445         LNN_LOGE(LNN_STATE, "read pkgName failed");
446         return SOFTBUS_INVALID_PARAM;
447     }
448     int32_t publishId;
449     ReadInt32(req, &publishId);
450     int32_t callingUid = GetCallingUid();
451     if (CheckPermission(pkgName, callingUid) != SOFTBUS_OK) {
452         LNN_LOGE(LNN_STATE, "no permission");
453         return SOFTBUS_PERMISSION_DENIED;
454     }
455     int32_t ret = LnnIpcStopPublishLNN(pkgName, publishId);
456     if (ret != SOFTBUS_OK) {
457         LNN_LOGE(LNN_STATE, "LnnIpcStopPublishLNN failed");
458         return SOFTBUS_ERR;
459     }
460     return SOFTBUS_OK;
461 }
462 
ServerRefreshLNN(IpcIo * req,IpcIo * reply)463 int32_t ServerRefreshLNN(IpcIo *req, IpcIo *reply)
464 {
465     LNN_LOGD(LNN_STATE, "ipc server pop");
466     LNN_CHECK_AND_RETURN_RET_LOGE((req != NULL && reply != NULL), SOFTBUS_INVALID_PARAM, LNN_STATE, "invalid param");
467 
468     size_t len;
469     const char *pkgName = (const char *)ReadString(req, &len);
470     if (pkgName == NULL || len >= PKG_NAME_SIZE_MAX) {
471         LNN_LOGE(LNN_STATE, "read pkgName failed");
472         return SOFTBUS_INVALID_PARAM;
473     }
474     int32_t callingUid = GetCallingUid();
475     LNN_CHECK_AND_RETURN_RET_LOGE((
476         CheckPermission(pkgName, callingUid) == SOFTBUS_OK), SOFTBUS_PERMISSION_DENIED, LNN_STATE, "no permission");
477 
478     SubscribeInfo info;
479     int32_t mode;
480     int32_t medium;
481     int32_t freq;
482     (void)memset_s(&info, sizeof(SubscribeInfo), 0, sizeof(SubscribeInfo));
483     LNN_CHECK_AND_RETURN_RET_LOGE(
484         ReadInt32(req, &info.subscribeId), SOFTBUS_IPC_ERR, LNN_STATE, "read subscribeId failed");
485     LNN_CHECK_AND_RETURN_RET_LOGE(ReadInt32(req, &mode), SOFTBUS_IPC_ERR, LNN_STATE, "read mode failed");
486     LNN_CHECK_AND_RETURN_RET_LOGE(ReadInt32(req, &medium), SOFTBUS_IPC_ERR, LNN_STATE, "read medium failed");
487     LNN_CHECK_AND_RETURN_RET_LOGE(ReadInt32(req, &freq), SOFTBUS_IPC_ERR, LNN_STATE, "read freq failed");
488     info.mode = (DiscoverMode)mode;
489     info.medium = (ExchangeMedium)medium;
490     info.freq = (ExchangeFreq)freq;
491     LNN_CHECK_AND_RETURN_RET_LOGE(
492         ReadBool(req, &info.isSameAccount), SOFTBUS_IPC_ERR, LNN_STATE, "read isSameAccount failed");
493     LNN_CHECK_AND_RETURN_RET_LOGE(
494         ReadBool(req, &info.isWakeRemote), SOFTBUS_IPC_ERR, LNN_STATE, "read isWakeRemote failed");
495     info.capability = (const char *)ReadString(req, &len);
496     LNN_CHECK_AND_RETURN_RET_LOGE((info.capability != NULL), SOFTBUS_IPC_ERR, LNN_STATE, "read capability failed");
497     LNN_CHECK_AND_RETURN_RET_LOGE(
498         ReadUint32(req, &info.dataLen), SOFTBUS_IPC_ERR, LNN_STATE, "read dataLen failed");
499     if (info.dataLen > 0 && info.dataLen < MAX_CAPABILITYDATA_LEN) {
500         info.capabilityData = (unsigned char *)ReadString(req, &len);
501         LNN_CHECK_AND_RETURN_RET_LOGE(
502             (info.capabilityData != NULL), SOFTBUS_IPC_ERR, LNN_STATE, "read capabilityData failed");
503     } else {
504         info.capabilityData = NULL;
505         info.dataLen = 0;
506     }
507     int32_t ret = LnnIpcRefreshLNN(pkgName, 0, &info);
508     LNN_CHECK_AND_RETURN_RET_LOGE(WriteInt32(reply, ret), ret, LNN_STATE, "write reply failed");
509     if (ret != SOFTBUS_OK) {
510         LNN_LOGE(LNN_STATE, "refresh LNN failed, ret = %{public}d", ret);
511     }
512     return ret;
513 }
514 
ServerStopRefreshLNN(IpcIo * req,IpcIo * reply)515 int32_t ServerStopRefreshLNN(IpcIo *req, IpcIo *reply)
516 {
517     LNN_LOGD(LNN_STATE, "ipc server pop");
518     if (req == NULL || reply == NULL) {
519         LNN_LOGE(LNN_STATE, "invalid param");
520         return SOFTBUS_INVALID_PARAM;
521     }
522     size_t len;
523     const char *pkgName = (const char *)ReadString(req, &len);
524     if (pkgName == NULL || len >= PKG_NAME_SIZE_MAX) {
525         LNN_LOGE(LNN_STATE, "read pkgName failed");
526         return SOFTBUS_INVALID_PARAM;
527     }
528     int32_t refreshId;
529     ReadInt32(req, &refreshId);
530     int32_t callingUid = GetCallingUid();
531     if (CheckPermission(pkgName, callingUid) != SOFTBUS_OK) {
532         LNN_LOGE(LNN_STATE, "no permission");
533         return SOFTBUS_PERMISSION_DENIED;
534     }
535     int32_t ret = LnnIpcStopRefreshLNN(pkgName, 0, refreshId);
536     if (ret != SOFTBUS_OK) {
537         LNN_LOGE(LNN_STATE, "LnnIpcStopRefreshLNN failed");
538         return SOFTBUS_ERR;
539     }
540     return SOFTBUS_OK;
541 }
542 
ServerActiveMetaNode(IpcIo * req,IpcIo * reply)543 int32_t ServerActiveMetaNode(IpcIo *req, IpcIo *reply)
544 {
545     uint32_t size;
546     const char *pkgName = (const char *)ReadString(req, &size);
547     if (pkgName == NULL || size >= PKG_NAME_SIZE_MAX) {
548         LNN_LOGE(LNN_STATE, "read pkgName failed");
549         return SOFTBUS_INVALID_PARAM;
550     }
551     MetaNodeConfigInfo *info = (MetaNodeConfigInfo *)ReadRawData(req, sizeof(MetaNodeConfigInfo));
552     if (info == NULL) {
553         LNN_LOGE(LNN_STATE, "read meta node config info failed");
554         WriteInt32(reply, SOFTBUS_INVALID_PARAM);
555         return SOFTBUS_ERR;
556     }
557     int32_t ret = CheckPermission(pkgName, GetCallingUid());
558     if (ret != SOFTBUS_OK) {
559         WriteInt32(reply, ret);
560         return SOFTBUS_ERR;
561     }
562     char metaNodeId[NETWORK_ID_BUF_LEN] = {0};
563     ret = LnnIpcActiveMetaNode(info, metaNodeId);
564     if (ret != SOFTBUS_OK) {
565         LNN_LOGE(LNN_STATE, "LnnIpcActiveMetaNode failed");
566         WriteInt32(reply, ret);
567         return SOFTBUS_ERR;
568     }
569     if (!(WriteInt32(reply, SOFTBUS_OK))) {
570         LNN_LOGE(LNN_STATE, "write SOFTBUS_OK to reply failed!");
571         return SOFTBUS_ERR;
572     }
573     if (!(WriteString(reply, metaNodeId))) {
574         LNN_LOGE(LNN_STATE, "write metaNodeId to reply failed!");
575         return SOFTBUS_ERR;
576     }
577     return SOFTBUS_OK;
578 }
579 
ServerDeactiveMetaNode(IpcIo * req,IpcIo * reply)580 int32_t ServerDeactiveMetaNode(IpcIo *req, IpcIo *reply)
581 {
582     uint32_t size;
583     const char *pkgName = (const char *)ReadString(req, &size);
584     if (pkgName == NULL || size >= PKG_NAME_SIZE_MAX) {
585         LNN_LOGE(LNN_STATE, "read pkgName failed");
586         return SOFTBUS_INVALID_PARAM;
587     }
588     const char *metaNodeId = (const char *)ReadString(req, &size);
589     if (metaNodeId == NULL || size != (NETWORK_ID_BUF_LEN - 1)) {
590         LNN_LOGE(LNN_STATE, "read meta node id failed, size=%{public}d", size);
591         WriteInt32(reply, SOFTBUS_INVALID_PARAM);
592         return SOFTBUS_ERR;
593     }
594     int32_t ret = CheckPermission(pkgName, GetCallingUid());
595     if (ret != SOFTBUS_OK) {
596         WriteInt32(reply, ret);
597         return SOFTBUS_ERR;
598     }
599     ret = LnnIpcDeactiveMetaNode(metaNodeId);
600     if (ret != SOFTBUS_OK) {
601         LNN_LOGE(LNN_STATE, "LnnIpcDeactiveMetaNode failed");
602         WriteInt32(reply, ret);
603         return SOFTBUS_ERR;
604     }
605     WriteInt32(reply, SOFTBUS_OK);
606     return SOFTBUS_OK;
607 }
608 
ServerGetAllMetaNodeInfo(IpcIo * req,IpcIo * reply)609 int32_t ServerGetAllMetaNodeInfo(IpcIo *req, IpcIo *reply)
610 {
611     uint32_t size;
612     const char *pkgName = (const char *)ReadString(req, &size);
613     if (pkgName == NULL || size >= PKG_NAME_SIZE_MAX) {
614         LNN_LOGE(LNN_STATE, "read pkgName failed");
615         return SOFTBUS_INVALID_PARAM;
616     }
617     int32_t infoNum;
618     if (!(ReadInt32(req, &infoNum))) {
619         LNN_LOGE(LNN_STATE, "read infoNum failed!");
620         return SOFTBUS_INVALID_PARAM;
621     }
622     if ((uint32_t)infoNum > MAX_META_NODE_NUM) {
623         LNN_LOGE(LNN_STATE, "inivalid param, infoNum=%{public}d, maxNum=%{public}d", infoNum, MAX_META_NODE_NUM);
624         return SOFTBUS_ERR;
625     }
626     MetaNodeInfo infos[MAX_META_NODE_NUM];
627     int32_t ret = CheckPermission(pkgName, GetCallingUid());
628     if (ret != SOFTBUS_OK) {
629         WriteInt32(reply, ret);
630         return SOFTBUS_ERR;
631     }
632     ret = LnnIpcGetAllMetaNodeInfo(infos, &infoNum);
633     if (ret != SOFTBUS_OK) {
634         LNN_LOGE(LNN_STATE, "LnnIpcGetAllMetaNodeInfo failed");
635         WriteInt32(reply, ret);
636         return SOFTBUS_ERR;
637     }
638     if (!(WriteInt32(reply, SOFTBUS_OK))) {
639         LNN_LOGE(LNN_STATE, "write SOFTBUS_OK to reply failed!");
640         return SOFTBUS_ERR;
641     }
642     if (!(WriteInt32(reply, infoNum))) {
643         LNN_LOGE(LNN_STATE, "write infoNum to reply failed!");
644         return SOFTBUS_ERR;
645     }
646     if (infoNum > 0) {
647         WriteUint32(reply, infoNum * sizeof(MetaNodeInfo));
648         WriteBuffer(reply, infos, infoNum * sizeof(MetaNodeInfo));
649     }
650     return SOFTBUS_OK;
651 }
652 
ServerShiftLnnGear(IpcIo * req,IpcIo * reply)653 int32_t ServerShiftLnnGear(IpcIo *req, IpcIo *reply)
654 {
655     size_t len;
656     bool targetNetworkIdIsNULL = false;
657     const char *targetNetworkId = NULL;
658 
659     const char *pkgName = (const char *)ReadString(req, &len);
660     if (pkgName == NULL || len >= PKG_NAME_SIZE_MAX) {
661         LNN_LOGE(LNN_STATE, "read pkgName failed");
662         goto ERR_RETURN;
663     }
664     const char *callerId = (const char *)ReadString(req, &len);
665     if (callerId == NULL || len == 0 || len >= CALLER_ID_MAX_LEN) {
666         LNN_LOGE(LNN_STATE, "read callerId failed");
667         goto ERR_RETURN;
668     }
669     if (!ReadBool(req, &targetNetworkIdIsNULL)) {
670         LNN_LOGE(LNN_STATE, "read targetNetworkIdIsNULL failed");
671         goto ERR_RETURN;
672     }
673     if (!targetNetworkIdIsNULL) {
674         targetNetworkId = (const char *)ReadString(req, &len);
675         if (targetNetworkId == NULL || len != NETWORK_ID_BUF_LEN - 1) {
676             LNN_LOGE(LNN_STATE, "read targetNetworkId failed");
677             goto ERR_RETURN;
678         }
679     }
680     const GearMode *mode = (GearMode *)ReadRawData(req, sizeof(GearMode));
681     if (mode == NULL) {
682         LNN_LOGE(LNN_STATE, "read gear mode info failed");
683         goto ERR_RETURN;
684     }
685     int32_t ret = CheckPermission(pkgName, GetCallingUid());
686     if (ret != SOFTBUS_OK) {
687         WriteInt32(reply, ret);
688         return SOFTBUS_PERMISSION_DENIED;
689     }
690     ret = LnnIpcShiftLNNGear(pkgName, callerId, targetNetworkId, mode);
691     if (ret != SOFTBUS_OK) {
692         LNN_LOGE(LNN_STATE, "LnnIpcShiftLNNGear failed");
693         WriteInt32(reply, ret);
694         return SOFTBUS_ERR;
695     }
696     if (!(WriteInt32(reply, SOFTBUS_OK))) {
697         LNN_LOGE(LNN_STATE, "write reply failed!");
698         return SOFTBUS_ERR;
699     }
700     return SOFTBUS_OK;
701 
702 ERR_RETURN:
703     WriteInt32(reply, SOFTBUS_INVALID_PARAM);
704     return SOFTBUS_ERR;
705 }
706