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_error_code.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_INVALID_PKGNAME;
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_INVALID_PARAM;
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, false);
73 if (ret != SOFTBUS_OK) {
74 LNN_LOGE(LNN_STATE, "LnnIpcServerJoin failed");
75 return ret;
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_INVALID_PARAM;
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 ret;
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, ret);
144 return ret;
145 }
146 if (infoNum < 0 || (infoNum > 0 && nodeInfo == NULL)) {
147 LNN_LOGE(LNN_STATE, "node info is invalid");
148 if (!(WriteInt32(reply, SOFTBUS_NETWORK_GET_ALL_NODE_INFO_ERR))) {
149 LNN_LOGE(LNN_STATE, "write reply failed!");
150 SoftBusFree(nodeInfo);
151 return SOFTBUS_NETWORK_WRITEINT32_FAILED;
152 }
153 }
154 if (!(WriteInt32(reply, infoNum))) {
155 LNN_LOGE(LNN_STATE, "write infoNum failed!");
156 SoftBusFree(nodeInfo);
157 return SOFTBUS_NETWORK_WRITEINT32_FAILED;
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 ret;
198 }
199 if (!(WriteUint32(reply, infoTypeLen))) {
200 LNN_LOGE(LNN_STATE, "write reply failed!");
201 SoftBusFree(nodeInfo);
202 return SOFTBUS_NETWORK_WRITEINT32_FAILED;
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_NETWORK_WRITEINT32_FAILED;
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_INVALID_PARAM;
237 }
238 int32_t key;
239 ReadInt32(req, &key);
240 int32_t infoLen = LnnIpcGetNodeKeyInfoLen(key);
241 if (infoLen == SOFTBUS_INVALID_NUM) {
242 LNN_LOGE(LNN_STATE, "get infoLen failed");
243 return SOFTBUS_INVALID_NUM;
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_INVALID_PARAM;
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 ret;
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_INVALID_PARAM;
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 ret;
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_INVALID_PARAM;
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 ret;
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_INVALID_PARAM;
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 ret;
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 callingPid = GetCallingPid();
379 int32_t ret = LnnIpcPublishLNN(pkgName, callingPid, info);
380 WriteInt32(reply, ret);
381 if (ret != SOFTBUS_OK) {
382 LNN_LOGE(LNN_STATE, "LnnIpcPublishLNN failed");
383 return ret;
384 }
385 return SOFTBUS_OK;
386 }
387
ServerPublishLNN(IpcIo * req,IpcIo * reply)388 int32_t ServerPublishLNN(IpcIo *req, IpcIo *reply)
389 {
390 LNN_LOGD(LNN_STATE, "ipc server pop");
391 if (req == NULL || reply == NULL) {
392 LNN_LOGE(LNN_STATE, "invalid param.");
393 return SOFTBUS_INVALID_PARAM;
394 }
395 size_t len;
396 const char *pkgName = (const char *)ReadString(req, &len);
397 if (pkgName == NULL || len >= PKG_NAME_SIZE_MAX) {
398 LNN_LOGE(LNN_STATE, "read pkgName failed");
399 return SOFTBUS_INVALID_PARAM;
400 }
401 int32_t callingUid = GetCallingUid();
402 if (CheckPermission(pkgName, callingUid) != SOFTBUS_OK) {
403 LNN_LOGE(LNN_STATE, "no permission");
404 return SOFTBUS_PERMISSION_DENIED;
405 }
406 PublishInfo info;
407 (void)memset_s(&info, sizeof(PublishInfo), 0, sizeof(PublishInfo));
408 ReadInt32(req, &info.publishId);
409 int32_t mode, medium, freq;
410 ReadInt32(req, &mode);
411 ReadInt32(req, &medium);
412 ReadInt32(req, &freq);
413 info.mode = (DiscoverMode)mode;
414 info.medium = (ExchangeMedium)medium;
415 info.freq = (ExchangeFreq)freq;
416 info.capability = (const char *)ReadString(req, &len);
417 if (info.capability == NULL) {
418 LNN_LOGE(LNN_STATE, "read capability is null");
419 return SOFTBUS_IPC_ERR;
420 }
421 ReadUint32(req, &info.dataLen);
422 if (info.dataLen > 0 && info.dataLen < MAX_CAPABILITYDATA_LEN) {
423 info.capabilityData = (unsigned char *)ReadString(req, &len);
424 if (info.capabilityData == NULL) {
425 LNN_LOGE(LNN_STATE, "read capabilityData is null");
426 return SOFTBUS_IPC_ERR;
427 }
428 } else {
429 info.capabilityData = NULL;
430 info.dataLen = 0;
431 }
432 ReadBool(req, &info.ranging);
433 return ServerRecoverPublishLNN(pkgName, &info, reply);
434 }
435
ServerStopPublishLNN(IpcIo * req,IpcIo * reply)436 int32_t ServerStopPublishLNN(IpcIo *req, IpcIo *reply)
437 {
438 LNN_LOGD(LNN_STATE, "ipc server pop");
439 if (req == NULL || reply == NULL) {
440 LNN_LOGE(LNN_STATE, "invalid param.");
441 return SOFTBUS_INVALID_PARAM;
442 }
443 size_t len;
444 const char *pkgName = (const char *)ReadString(req, &len);
445 if (pkgName == NULL || len >= PKG_NAME_SIZE_MAX) {
446 LNN_LOGE(LNN_STATE, "read pkgName failed");
447 return SOFTBUS_INVALID_PARAM;
448 }
449 int32_t publishId;
450 ReadInt32(req, &publishId);
451 int32_t callingUid = GetCallingUid();
452 if (CheckPermission(pkgName, callingUid) != SOFTBUS_OK) {
453 LNN_LOGE(LNN_STATE, "no permission");
454 return SOFTBUS_PERMISSION_DENIED;
455 }
456 int32_t callingPid = GetCallingPid();
457 int32_t ret = LnnIpcStopPublishLNN(pkgName, callingPid, publishId);
458 if (ret != SOFTBUS_OK) {
459 LNN_LOGE(LNN_STATE, "LnnIpcStopPublishLNN failed");
460 return ret;
461 }
462 return SOFTBUS_OK;
463 }
464
ServerRefreshLNN(IpcIo * req,IpcIo * reply)465 int32_t ServerRefreshLNN(IpcIo *req, IpcIo *reply)
466 {
467 LNN_LOGD(LNN_STATE, "ipc server pop");
468 LNN_CHECK_AND_RETURN_RET_LOGE((req != NULL && reply != NULL), SOFTBUS_INVALID_PARAM, LNN_STATE, "invalid param");
469
470 size_t len;
471 const char *pkgName = (const char *)ReadString(req, &len);
472 if (pkgName == NULL || len >= PKG_NAME_SIZE_MAX) {
473 LNN_LOGE(LNN_STATE, "read pkgName failed");
474 return SOFTBUS_INVALID_PARAM;
475 }
476 int32_t callingUid = GetCallingUid();
477 LNN_CHECK_AND_RETURN_RET_LOGE((
478 CheckPermission(pkgName, callingUid) == SOFTBUS_OK), SOFTBUS_PERMISSION_DENIED, LNN_STATE, "no permission");
479
480 SubscribeInfo info;
481 int32_t mode;
482 int32_t medium;
483 int32_t freq;
484 (void)memset_s(&info, sizeof(SubscribeInfo), 0, sizeof(SubscribeInfo));
485 LNN_CHECK_AND_RETURN_RET_LOGE(
486 ReadInt32(req, &info.subscribeId), SOFTBUS_IPC_ERR, LNN_STATE, "read subscribeId failed");
487 LNN_CHECK_AND_RETURN_RET_LOGE(ReadInt32(req, &mode), SOFTBUS_IPC_ERR, LNN_STATE, "read mode failed");
488 LNN_CHECK_AND_RETURN_RET_LOGE(ReadInt32(req, &medium), SOFTBUS_IPC_ERR, LNN_STATE, "read medium failed");
489 LNN_CHECK_AND_RETURN_RET_LOGE(ReadInt32(req, &freq), SOFTBUS_IPC_ERR, LNN_STATE, "read freq failed");
490 info.mode = (DiscoverMode)mode;
491 info.medium = (ExchangeMedium)medium;
492 info.freq = (ExchangeFreq)freq;
493 LNN_CHECK_AND_RETURN_RET_LOGE(
494 ReadBool(req, &info.isSameAccount), SOFTBUS_IPC_ERR, LNN_STATE, "read isSameAccount failed");
495 LNN_CHECK_AND_RETURN_RET_LOGE(
496 ReadBool(req, &info.isWakeRemote), SOFTBUS_IPC_ERR, LNN_STATE, "read isWakeRemote failed");
497 info.capability = (const char *)ReadString(req, &len);
498 LNN_CHECK_AND_RETURN_RET_LOGE((info.capability != NULL), SOFTBUS_IPC_ERR, LNN_STATE, "read capability failed");
499 LNN_CHECK_AND_RETURN_RET_LOGE(
500 ReadUint32(req, &info.dataLen), SOFTBUS_IPC_ERR, LNN_STATE, "read dataLen failed");
501 if (info.dataLen > 0 && info.dataLen < MAX_CAPABILITYDATA_LEN) {
502 info.capabilityData = (unsigned char *)ReadString(req, &len);
503 LNN_CHECK_AND_RETURN_RET_LOGE(
504 (info.capabilityData != NULL), SOFTBUS_IPC_ERR, LNN_STATE, "read capabilityData failed");
505 } else {
506 info.capabilityData = NULL;
507 info.dataLen = 0;
508 }
509 int32_t callingPid = GetCallingPid();
510 int32_t ret = LnnIpcRefreshLNN(pkgName, callingPid, &info);
511 LNN_CHECK_AND_RETURN_RET_LOGE(WriteInt32(reply, ret), ret, LNN_STATE, "write reply failed");
512 if (ret != SOFTBUS_OK) {
513 LNN_LOGE(LNN_STATE, "refresh LNN failed, ret = %{public}d", ret);
514 }
515 return ret;
516 }
517
ServerStopRefreshLNN(IpcIo * req,IpcIo * reply)518 int32_t ServerStopRefreshLNN(IpcIo *req, IpcIo *reply)
519 {
520 LNN_LOGD(LNN_STATE, "ipc server pop");
521 if (req == NULL || reply == NULL) {
522 LNN_LOGE(LNN_STATE, "invalid param");
523 return SOFTBUS_INVALID_PARAM;
524 }
525 size_t len;
526 const char *pkgName = (const char *)ReadString(req, &len);
527 if (pkgName == NULL || len >= PKG_NAME_SIZE_MAX) {
528 LNN_LOGE(LNN_STATE, "read pkgName failed");
529 return SOFTBUS_INVALID_PARAM;
530 }
531 int32_t refreshId;
532 ReadInt32(req, &refreshId);
533 int32_t callingUid = GetCallingUid();
534 if (CheckPermission(pkgName, callingUid) != SOFTBUS_OK) {
535 LNN_LOGE(LNN_STATE, "no permission");
536 return SOFTBUS_PERMISSION_DENIED;
537 }
538 int32_t callingPid = GetCallingPid();
539 int32_t ret = LnnIpcStopRefreshLNN(pkgName, callingPid, refreshId);
540 if (ret != SOFTBUS_OK) {
541 LNN_LOGE(LNN_STATE, "LnnIpcStopRefreshLNN failed");
542 return ret;
543 }
544 return SOFTBUS_OK;
545 }
546
ServerActiveMetaNode(IpcIo * req,IpcIo * reply)547 int32_t ServerActiveMetaNode(IpcIo *req, IpcIo *reply)
548 {
549 size_t size;
550 const char *pkgName = (const char *)ReadString(req, &size);
551 if (pkgName == NULL || size >= PKG_NAME_SIZE_MAX) {
552 LNN_LOGE(LNN_STATE, "read pkgName failed");
553 return SOFTBUS_INVALID_PARAM;
554 }
555 MetaNodeConfigInfo *info = (MetaNodeConfigInfo *)ReadRawData(req, sizeof(MetaNodeConfigInfo));
556 if (info == NULL) {
557 LNN_LOGE(LNN_STATE, "read meta node config info failed");
558 WriteInt32(reply, SOFTBUS_INVALID_PARAM);
559 return SOFTBUS_IPC_ERR;
560 }
561 int32_t ret = CheckPermission(pkgName, GetCallingUid());
562 if (ret != SOFTBUS_OK) {
563 WriteInt32(reply, ret);
564 return ret;
565 }
566 char metaNodeId[NETWORK_ID_BUF_LEN] = {0};
567 ret = LnnIpcActiveMetaNode(info, metaNodeId);
568 if (ret != SOFTBUS_OK) {
569 LNN_LOGE(LNN_STATE, "LnnIpcActiveMetaNode failed");
570 WriteInt32(reply, ret);
571 return ret;
572 }
573 if (!(WriteInt32(reply, SOFTBUS_OK))) {
574 LNN_LOGE(LNN_STATE, "write SOFTBUS_OK to reply failed!");
575 return SOFTBUS_NETWORK_WRITEINT32_FAILED;
576 }
577 if (!(WriteString(reply, metaNodeId))) {
578 LNN_LOGE(LNN_STATE, "write metaNodeId to reply failed!");
579 return SOFTBUS_NETWORK_WRITEINT32_FAILED;
580 }
581 return SOFTBUS_OK;
582 }
583
ServerDeactiveMetaNode(IpcIo * req,IpcIo * reply)584 int32_t ServerDeactiveMetaNode(IpcIo *req, IpcIo *reply)
585 {
586 size_t size;
587 const char *pkgName = (const char *)ReadString(req, &size);
588 if (pkgName == NULL || size >= PKG_NAME_SIZE_MAX) {
589 LNN_LOGE(LNN_STATE, "read pkgName failed");
590 return SOFTBUS_INVALID_PARAM;
591 }
592 const char *metaNodeId = (const char *)ReadString(req, &size);
593 if (metaNodeId == NULL || size != (NETWORK_ID_BUF_LEN - 1)) {
594 LNN_LOGE(LNN_STATE, "read meta node id failed, size=%{public}d", size);
595 WriteInt32(reply, SOFTBUS_INVALID_PARAM);
596 return SOFTBUS_INVALID_PARAM;
597 }
598 int32_t ret = CheckPermission(pkgName, GetCallingUid());
599 if (ret != SOFTBUS_OK) {
600 WriteInt32(reply, ret);
601 return ret;
602 }
603 ret = LnnIpcDeactiveMetaNode(metaNodeId);
604 if (ret != SOFTBUS_OK) {
605 LNN_LOGE(LNN_STATE, "LnnIpcDeactiveMetaNode failed");
606 WriteInt32(reply, ret);
607 return ret;
608 }
609 WriteInt32(reply, SOFTBUS_OK);
610 return SOFTBUS_OK;
611 }
612
ServerGetAllMetaNodeInfo(IpcIo * req,IpcIo * reply)613 int32_t ServerGetAllMetaNodeInfo(IpcIo *req, IpcIo *reply)
614 {
615 size_t size;
616 const char *pkgName = (const char *)ReadString(req, &size);
617 if (pkgName == NULL || size >= PKG_NAME_SIZE_MAX) {
618 LNN_LOGE(LNN_STATE, "read pkgName failed");
619 return SOFTBUS_INVALID_PARAM;
620 }
621 int32_t infoNum;
622 if (!(ReadInt32(req, &infoNum))) {
623 LNN_LOGE(LNN_STATE, "read infoNum failed!");
624 return SOFTBUS_INVALID_PARAM;
625 }
626 if ((uint32_t)infoNum > MAX_META_NODE_NUM) {
627 LNN_LOGE(LNN_STATE, "inivalid param, infoNum=%{public}d, maxNum=%{public}d", infoNum, MAX_META_NODE_NUM);
628 return SOFTBUS_INVALID_PARAM;
629 }
630 MetaNodeInfo infos[MAX_META_NODE_NUM];
631 int32_t ret = CheckPermission(pkgName, GetCallingUid());
632 if (ret != SOFTBUS_OK) {
633 WriteInt32(reply, ret);
634 return ret;
635 }
636 ret = LnnIpcGetAllMetaNodeInfo(infos, &infoNum);
637 if (ret != SOFTBUS_OK) {
638 LNN_LOGE(LNN_STATE, "LnnIpcGetAllMetaNodeInfo failed");
639 WriteInt32(reply, ret);
640 return ret;
641 }
642 if (!(WriteInt32(reply, SOFTBUS_OK))) {
643 LNN_LOGE(LNN_STATE, "write SOFTBUS_OK to reply failed!");
644 return SOFTBUS_NETWORK_WRITEINT32_FAILED;
645 }
646 if (!(WriteInt32(reply, infoNum))) {
647 LNN_LOGE(LNN_STATE, "write infoNum to reply failed!");
648 return SOFTBUS_NETWORK_WRITEINT32_FAILED;
649 }
650 if (infoNum > 0) {
651 WriteUint32(reply, infoNum * sizeof(MetaNodeInfo));
652 WriteBuffer(reply, infos, infoNum * sizeof(MetaNodeInfo));
653 }
654 return SOFTBUS_OK;
655 }
656
ServerShiftLnnGear(IpcIo * req,IpcIo * reply)657 int32_t ServerShiftLnnGear(IpcIo *req, IpcIo *reply)
658 {
659 size_t len;
660 bool targetNetworkIdIsNULL = false;
661 const char *targetNetworkId = NULL;
662
663 const char *pkgName = (const char *)ReadString(req, &len);
664 if (pkgName == NULL || len >= PKG_NAME_SIZE_MAX) {
665 LNN_LOGE(LNN_STATE, "read pkgName failed");
666 goto ERR_RETURN;
667 }
668 const char *callerId = (const char *)ReadString(req, &len);
669 if (callerId == NULL || len == 0 || len >= CALLER_ID_MAX_LEN) {
670 LNN_LOGE(LNN_STATE, "read callerId failed");
671 goto ERR_RETURN;
672 }
673 if (!ReadBool(req, &targetNetworkIdIsNULL)) {
674 LNN_LOGE(LNN_STATE, "read targetNetworkIdIsNULL failed");
675 goto ERR_RETURN;
676 }
677 if (!targetNetworkIdIsNULL) {
678 targetNetworkId = (const char *)ReadString(req, &len);
679 if (targetNetworkId == NULL || len != NETWORK_ID_BUF_LEN - 1) {
680 LNN_LOGE(LNN_STATE, "read targetNetworkId failed");
681 goto ERR_RETURN;
682 }
683 }
684 const GearMode *mode = (GearMode *)ReadRawData(req, sizeof(GearMode));
685 if (mode == NULL) {
686 LNN_LOGE(LNN_STATE, "read gear mode info failed");
687 goto ERR_RETURN;
688 }
689 int32_t ret = CheckPermission(pkgName, GetCallingUid());
690 if (ret != SOFTBUS_OK) {
691 WriteInt32(reply, ret);
692 return SOFTBUS_PERMISSION_DENIED;
693 }
694 ret = LnnIpcShiftLNNGear(pkgName, callerId, targetNetworkId, mode);
695 if (ret != SOFTBUS_OK) {
696 LNN_LOGE(LNN_STATE, "LnnIpcShiftLNNGear failed");
697 WriteInt32(reply, ret);
698 return ret;
699 }
700 if (!(WriteInt32(reply, SOFTBUS_OK))) {
701 LNN_LOGE(LNN_STATE, "write reply failed!");
702 return SOFTBUS_NETWORK_WRITEINT32_FAILED;
703 }
704 return SOFTBUS_OK;
705
706 ERR_RETURN:
707 WriteInt32(reply, SOFTBUS_INVALID_PARAM);
708 return SOFTBUS_IPC_ERR;
709 }
710
ServerTriggerRangeForMsdp(IpcIo * req,IpcIo * reply)711 int32_t ServerTriggerRangeForMsdp(IpcIo *req, IpcIo *reply)
712 {
713 (void)req;
714 (void)reply;
715 return SOFTBUS_FUNC_NOT_SUPPORT;
716 }
717
ServerRegRangeCbForMsdp(IpcIo * req,IpcIo * reply)718 int32_t ServerRegRangeCbForMsdp(IpcIo *req, IpcIo *reply)
719 {
720 (void)req;
721 (void)reply;
722 return SOFTBUS_FUNC_NOT_SUPPORT;
723 }
724
ServerUnregRangeCbForMsdp(IpcIo * req,IpcIo * reply)725 int32_t ServerUnregRangeCbForMsdp(IpcIo *req, IpcIo *reply)
726 {
727 (void)req;
728 (void)reply;
729 return SOFTBUS_FUNC_NOT_SUPPORT;
730 }
731