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