1 /* 2 * Copyright (c) 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 <cerrno> 17 #include <cstdlib> 18 #include <cstring> 19 #include <memory> 20 #include <string> 21 #include <unistd.h> 22 #include <gtest/gtest.h> 23 #include <sys/stat.h> 24 #include <sys/types.h> 25 #include <cJSON.h> 26 27 #include "appspawn_modulemgr.h" 28 #include "appspawn_server.h" 29 #include "appspawn_manager.h" 30 #include "appspawn_adapter.h" 31 #include "appspawn_encaps.h" 32 #include "appspawn.h" 33 #include "appspawn_hook.h" 34 #include "appspawn_permission.h" 35 #include "appspawn_hisysevent.h" 36 #include "app_spawn_stub.h" 37 #include "app_spawn_test_helper.h" 38 #include "securec.h" 39 40 using namespace testing; 41 using namespace testing::ext; 42 using namespace OHOS; 43 44 namespace OHOS { 45 static AppSpawnTestHelper g_testHelper; 46 class AppSpawnCommonTest : public testing::Test { 47 public: SetUpTestCase()48 static void SetUpTestCase() {} TearDownTestCase()49 static void TearDownTestCase() {} SetUp()50 void SetUp() {} TearDown()51 void TearDown() {} 52 }; 53 54 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_001, TestSize.Level0) 55 { 56 int ret = SetSelinuxConNweb(nullptr, nullptr); 57 EXPECT_EQ(ret, 0); 58 } 59 60 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_002, TestSize.Level0) 61 { 62 int ret = SetAppAccessToken(nullptr, nullptr); 63 EXPECT_NE(ret, 0); 64 } 65 66 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_003, TestSize.Level0) 67 { 68 AppSpawnClientHandle clientHandle = nullptr; 69 AppSpawnReqMsgHandle reqHandle = 0; 70 AppSpawningCtx *property = nullptr; 71 AppSpawnMgr *mgr = nullptr; 72 int ret = -1; 73 do { 74 mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN); 75 EXPECT_EQ(mgr != nullptr, 1); 76 // create msg 77 ret = AppSpawnClientInit(NWEBSPAWN_SERVER_NAME, &clientHandle); 78 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 79 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0); 80 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 81 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 82 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 83 property->client.flags |= APP_DEVELOPER_MODE; 84 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 85 ret = SetSelinuxCon(mgr, property); 86 } while (0); 87 DeleteAppSpawningCtx(property); 88 AppSpawnClientDestroy(clientHandle); 89 DeleteAppSpawnMgr(mgr); 90 ASSERT_EQ(ret, 0); 91 } 92 93 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_004, TestSize.Level0) 94 { 95 AppSpawnClientHandle clientHandle = nullptr; 96 AppSpawnReqMsgHandle reqHandle = 0; 97 AppSpawningCtx *property = nullptr; 98 AppSpawnMgr *mgr = nullptr; 99 int ret = -1; 100 do { 101 mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN); 102 EXPECT_EQ(mgr != nullptr, 1); 103 // create msg 104 ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle); 105 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 106 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0); 107 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 108 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 109 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 110 property->client.flags |= APP_BEGETCTL_BOOT; 111 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 112 ret = SetSelinuxCon(mgr, property); 113 } while (0); 114 DeleteAppSpawningCtx(property); 115 AppSpawnClientDestroy(clientHandle); 116 DeleteAppSpawnMgr(mgr); 117 ASSERT_EQ(ret, APPSPAWN_NATIVE_NOT_SUPPORT); 118 } 119 120 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_005, TestSize.Level0) 121 { 122 AppSpawnClientHandle clientHandle = nullptr; 123 AppSpawnReqMsgHandle reqHandle = 0; 124 AppSpawningCtx *property = nullptr; 125 AppSpawnMgr *mgr = nullptr; 126 int ret = -1; 127 do { 128 mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN); 129 EXPECT_EQ(mgr != nullptr, 1); 130 // create msg 131 ret = AppSpawnClientInit(NWEBSPAWN_SERVER_NAME, &clientHandle); 132 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 133 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0); 134 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 135 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 136 137 ret = AppSpawnReqMsgAddExtInfo(reqHandle, MSG_EXT_NAME_PROCESS_TYPE, 138 reinterpret_cast<uint8_t *>(const_cast<char *>("render")), 7); // 7 is value len 139 APPSPAWN_CHECK_ONLY_EXPER(ret == 0, break); 140 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 141 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 142 ret = SetSeccompFilter(mgr, property); 143 } while (0); 144 DeleteAppSpawningCtx(property); 145 AppSpawnClientDestroy(clientHandle); 146 DeleteAppSpawnMgr(mgr); 147 ASSERT_EQ(ret, 0); 148 } 149 150 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_006, TestSize.Level0) 151 { 152 AppSpawnClientHandle clientHandle = nullptr; 153 AppSpawnReqMsgHandle reqHandle = 0; 154 AppSpawningCtx *property = nullptr; 155 AppSpawnMgr *mgr = nullptr; 156 int ret = -1; 157 do { 158 mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN); 159 EXPECT_EQ(mgr != nullptr, 1); 160 // create msg 161 ret = AppSpawnClientInit(NWEBSPAWN_SERVER_NAME, &clientHandle); 162 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 163 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0); 164 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 165 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 166 167 ret = AppSpawnReqMsgAddExtInfo(reqHandle, MSG_EXT_NAME_PROCESS_TYPE, 168 reinterpret_cast<uint8_t *>(const_cast<char *>("xxx")), 7); // 7 is value len 169 APPSPAWN_CHECK_ONLY_EXPER(ret == 0, break); 170 ret = AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_ISOLATED_SANDBOX); 171 APPSPAWN_CHECK_ONLY_EXPER(ret == 0, break); 172 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 173 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 174 ret = SetSeccompFilter(mgr, property); 175 } while (0); 176 DeleteAppSpawningCtx(property); 177 AppSpawnClientDestroy(clientHandle); 178 DeleteAppSpawnMgr(mgr); 179 ASSERT_EQ(ret, 0); 180 } 181 182 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_007, TestSize.Level0) 183 { 184 AppSpawnClientHandle clientHandle = nullptr; 185 AppSpawnReqMsgHandle reqHandle = 0; 186 AppSpawningCtx *property = nullptr; 187 AppSpawnMgr *mgr = nullptr; 188 int ret = -1; 189 do { 190 mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN); 191 EXPECT_EQ(mgr != nullptr, 1); 192 // create msg 193 ret = AppSpawnClientInit(NWEBSPAWN_SERVER_NAME, &clientHandle); 194 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 195 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0); 196 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 197 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 198 199 ret = AppSpawnReqMsgAddExtInfo(reqHandle, MSG_EXT_NAME_PROCESS_TYPE, 200 reinterpret_cast<uint8_t *>(const_cast<char *>("xxx")), 7); // 7 is value len 201 APPSPAWN_CHECK_ONLY_EXPER(ret == 0, break); 202 ret = AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_IGNORE_SANDBOX); 203 APPSPAWN_CHECK_ONLY_EXPER(ret == 0, break); 204 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 205 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 206 ret = SetSeccompFilter(mgr, property); 207 } while (0); 208 DeleteAppSpawningCtx(property); 209 AppSpawnClientDestroy(clientHandle); 210 DeleteAppSpawnMgr(mgr); 211 ASSERT_EQ(ret, 0); 212 } 213 214 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_008, TestSize.Level0) 215 { 216 AppSpawnClientHandle clientHandle = nullptr; 217 AppSpawnReqMsgHandle reqHandle = 0; 218 AppSpawningCtx *property = nullptr; 219 AppSpawnMgr *mgr = nullptr; 220 int ret = -1; 221 do { 222 mgr = CreateAppSpawnMgr(MODE_FOR_APP_SPAWN); 223 EXPECT_EQ(mgr != nullptr, 1); 224 // create msg 225 ret = AppSpawnClientInit(NWEBSPAWN_SERVER_NAME, &clientHandle); 226 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 227 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0); 228 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 229 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 230 231 ret = AppSpawnReqMsgAddExtInfo(reqHandle, MSG_EXT_NAME_PROCESS_TYPE, 232 reinterpret_cast<uint8_t *>(const_cast<char *>("xxx")), 7); // 7 is value len 233 APPSPAWN_CHECK_ONLY_EXPER(ret == 0, break); 234 ret = AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_IGNORE_SANDBOX); 235 APPSPAWN_CHECK_ONLY_EXPER(ret == 0, break); 236 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 237 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 238 ret = SetSeccompFilter(mgr, property); 239 } while (0); 240 DeleteAppSpawningCtx(property); 241 AppSpawnClientDestroy(clientHandle); 242 DeleteAppSpawnMgr(mgr); 243 ASSERT_EQ(ret, 0); 244 } 245 246 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_009, TestSize.Level0) 247 { 248 AppSpawnClientHandle clientHandle = nullptr; 249 AppSpawnReqMsgHandle reqHandle = 0; 250 AppSpawningCtx *property = nullptr; 251 int ret = -1; 252 do { 253 // create msg 254 ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle); 255 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 256 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0); 257 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 258 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 259 ret = AppSpawnReqMsgSetAppInternetPermissionInfo(reqHandle, 0, 0); 260 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 261 ret = SetInternetPermission(property); 262 } while (0); 263 DeleteAppSpawningCtx(property); 264 AppSpawnClientDestroy(clientHandle); 265 ASSERT_EQ(ret, 0); 266 } 267 268 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_010, TestSize.Level0) 269 { 270 AppSpawnClientHandle clientHandle = nullptr; 271 AppSpawnReqMsgHandle reqHandle = 0; 272 AppSpawningCtx *property = nullptr; 273 int ret = -1; 274 do { 275 // create msg 276 ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle); 277 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 278 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0); 279 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 280 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 281 ret = AppSpawnReqMsgSetAppInternetPermissionInfo(reqHandle, 0, 1); 282 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 283 ret = SetInternetPermission(property); 284 } while (0); 285 DeleteAppSpawningCtx(property); 286 AppSpawnClientDestroy(clientHandle); 287 ASSERT_EQ(ret, 0); 288 } 289 290 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_011, TestSize.Level0) 291 { 292 AppSpawnClientHandle clientHandle = nullptr; 293 AppSpawnReqMsgHandle reqHandle = 0; 294 AppSpawningCtx *property = nullptr; 295 int ret = -1; 296 do { 297 // create msg 298 ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle); 299 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 300 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0); 301 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 302 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 303 ret = AppSpawnReqMsgSetAppInternetPermissionInfo(reqHandle, 1, 0); 304 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 305 ret = SetInternetPermission(property); 306 } while (0); 307 DeleteAppSpawningCtx(property); 308 AppSpawnClientDestroy(clientHandle); 309 ASSERT_EQ(ret, 0); 310 } 311 312 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_012, TestSize.Level0) 313 { 314 AppSpawnClientHandle clientHandle = nullptr; 315 AppSpawnReqMsgHandle reqHandle = 0; 316 AppSpawningCtx *property = nullptr; 317 int ret = -1; 318 do { 319 // create msg 320 ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle); 321 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 322 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0); 323 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 324 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 325 ret = AppSpawnReqMsgSetAppInternetPermissionInfo(reqHandle, 1, 1); 326 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 327 ret = SetInternetPermission(property); 328 } while (0); 329 DeleteAppSpawningCtx(property); 330 AppSpawnClientDestroy(clientHandle); 331 ASSERT_EQ(ret, 0); 332 } 333 334 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_013, TestSize.Level0) 335 { 336 AppSpawnClientHandle clientHandle = nullptr; 337 AppSpawnReqMsgHandle reqHandle = 0; 338 AppSpawningCtx *property = nullptr; 339 AppSpawnMgr *mgr = nullptr; 340 int ret = -1; 341 do { 342 mgr = CreateAppSpawnMgr(MODE_FOR_APP_SPAWN); 343 EXPECT_EQ(mgr != nullptr, 1); 344 // create msg 345 ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle); 346 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 347 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0); 348 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 349 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 350 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 351 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 352 ret = SetFdEnv(nullptr, nullptr); 353 ASSERT_EQ(ret, -1); 354 ret = SetFdEnv(mgr, property); 355 } while (0); 356 DeleteAppSpawningCtx(property); 357 AppSpawnClientDestroy(clientHandle); 358 DeleteAppSpawnMgr(mgr); 359 ASSERT_EQ(ret, -1); 360 } 361 362 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_014, TestSize.Level0) 363 { 364 NsInitFunc(); 365 EXPECT_EQ(GetNsPidFd(-1), -1); 366 GetPidByName("///////"); 367 } 368 369 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_015, TestSize.Level0) 370 { 371 AppSpawnMgr *mgr = nullptr; 372 int ret = -1; 373 mgr = CreateAppSpawnMgr(MODE_FOR_APP_SPAWN); 374 EXPECT_EQ(mgr != nullptr, 1); 375 mgr->content.sandboxNsFlags = 0; 376 PreLoadEnablePidNs(mgr); 377 DeleteAppSpawnMgr(mgr); 378 ASSERT_NE(ret, 0); 379 } 380 381 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_016, TestSize.Level0) 382 { 383 HOOK_MGR *hookMgr = GetAppSpawnHookMgr(); 384 EXPECT_EQ(hookMgr != nullptr, 1); 385 DeleteAppSpawnHookMgr(); 386 AppSpawnHiSysEventWrite(); 387 } 388 389 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_021, TestSize.Level0) 390 { 391 int ret = SetInternetPermission(nullptr); 392 ASSERT_EQ(ret, 0); 393 } 394 395 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_022, TestSize.Level0) 396 { 397 AppSpawnClientHandle clientHandle = nullptr; 398 AppSpawnReqMsgHandle reqHandle = 0; 399 AppSpawningCtx *property = nullptr; 400 int ret = -1; 401 do { 402 ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle); 403 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 404 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0); 405 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 406 const char *appEnv = "{\"test\"}"; 407 ret = AppSpawnReqMsgAddExtInfo(reqHandle, "AppEnv", 408 reinterpret_cast<uint8_t *>(const_cast<char *>(appEnv)), strlen(appEnv) + 1); 409 APPSPAWN_CHECK(ret == 0, break, "Failed to add ext tlv %{public}s", appEnv); 410 411 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 412 reqHandle = nullptr; 413 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 414 SetEnvInfo(nullptr, property); 415 // spawn 416 property = nullptr; 417 } while (0); 418 DeleteAppSpawningCtx(property); 419 AppSpawnReqMsgFree(reqHandle); 420 AppSpawnClientDestroy(clientHandle); 421 ASSERT_EQ(ret, 0); 422 } 423 424 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_023, TestSize.Level0) 425 { 426 AppSpawnClientHandle clientHandle = nullptr; 427 AppSpawnReqMsgHandle reqHandle = 0; 428 AppSpawningCtx *property = nullptr; 429 int ret = -1; 430 do { 431 ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle); 432 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 433 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0); 434 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 435 const char *appEnv = "%"; 436 ret = AppSpawnReqMsgAddExtInfo(reqHandle, "AppEnv", 437 reinterpret_cast<uint8_t *>(const_cast<char *>(appEnv)), strlen(appEnv) + 1); 438 APPSPAWN_CHECK(ret == 0, break, "Failed to add ext tlv %{public}s", appEnv); 439 440 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 441 reqHandle = nullptr; 442 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 443 SetEnvInfo(nullptr, property); 444 // spawn 445 property = nullptr; 446 } while (0); 447 DeleteAppSpawningCtx(property); 448 AppSpawnReqMsgFree(reqHandle); 449 AppSpawnClientDestroy(clientHandle); 450 ASSERT_EQ(ret, 0); 451 } 452 453 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_024, TestSize.Level0) 454 { 455 AppSpawnClientHandle clientHandle = nullptr; 456 AppSpawnReqMsgHandle reqHandle = 0; 457 AppSpawningCtx *property = nullptr; 458 int ret = -1; 459 do { 460 ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle); 461 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 462 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0); 463 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 464 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 465 reqHandle = nullptr; 466 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 467 SetEnvInfo(nullptr, property); 468 // spawn 469 property = nullptr; 470 } while (0); 471 DeleteAppSpawningCtx(property); 472 AppSpawnReqMsgFree(reqHandle); 473 AppSpawnClientDestroy(clientHandle); 474 ASSERT_EQ(ret, 0); 475 } 476 477 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_025, TestSize.Level0) 478 { 479 AppSpawnClientHandle clientHandle = nullptr; 480 AppSpawnReqMsgHandle reqHandle = 0; 481 AppSpawningCtx *property = nullptr; 482 AppSpawnMgr *mgr = nullptr; 483 int ret = -1; 484 do { 485 mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN); 486 EXPECT_EQ(mgr != nullptr, 1); 487 // create msg 488 ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle); 489 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 490 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0); 491 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 492 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 493 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 494 property->client.flags |= APP_BEGETCTL_BOOT; 495 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 496 SetAppSpawnMsgFlag(property->message, APP_FLAGS_ISOLATED_SANDBOX, 16); 497 ret = SetSelinuxCon(mgr, property); 498 } while (0); 499 DeleteAppSpawningCtx(property); 500 AppSpawnClientDestroy(clientHandle); 501 DeleteAppSpawnMgr(mgr); 502 ASSERT_EQ(ret, APPSPAWN_NATIVE_NOT_SUPPORT); 503 } 504 505 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_026, TestSize.Level0) 506 { 507 AppSpawnClientHandle clientHandle = nullptr; 508 AppSpawnReqMsgHandle reqHandle = 0; 509 AppSpawningCtx *property = nullptr; 510 AppSpawnMgr *mgr = nullptr; 511 int ret = -1; 512 do { 513 mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN); 514 EXPECT_EQ(mgr != nullptr, 1); 515 // create msg 516 ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle); 517 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 518 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0); 519 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 520 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 521 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 522 property->client.flags |= APP_BEGETCTL_BOOT; 523 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 524 SetAppSpawnMsgFlag(property->message, APP_FLAGS_DLP_MANAGER, 1); 525 ret = SetSelinuxCon(mgr, property); 526 } while (0); 527 DeleteAppSpawningCtx(property); 528 AppSpawnClientDestroy(clientHandle); 529 DeleteAppSpawnMgr(mgr); 530 ASSERT_EQ(ret, APPSPAWN_NATIVE_NOT_SUPPORT); 531 } 532 533 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_027, TestSize.Level0) 534 { 535 AppSpawnClientHandle clientHandle = nullptr; 536 AppSpawnReqMsgHandle reqHandle = 0; 537 AppSpawningCtx *property = nullptr; 538 AppSpawnMgr *mgr = nullptr; 539 int ret = -1; 540 do { 541 mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN); 542 EXPECT_EQ(mgr != nullptr, 1); 543 // create msg 544 ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle); 545 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 546 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0); 547 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 548 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 549 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 550 property->client.flags |= APP_BEGETCTL_BOOT; 551 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 552 SetAppSpawnMsgFlag(property->message, APP_FLAGS_DEBUGGABLE, 1); 553 ret = SetSelinuxCon(mgr, property); 554 } while (0); 555 DeleteAppSpawningCtx(property); 556 AppSpawnClientDestroy(clientHandle); 557 DeleteAppSpawnMgr(mgr); 558 ASSERT_EQ(ret, APPSPAWN_NATIVE_NOT_SUPPORT); 559 } 560 561 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_028, TestSize.Level0) 562 { 563 ASSERT_EQ(GetAppSpawnNamespace(nullptr), nullptr); 564 } 565 566 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_029, TestSize.Level0) 567 { 568 DeleteAppSpawnNamespace(nullptr); 569 FreeAppSpawnNamespace(nullptr); 570 AppSpawnMgr *mgr = nullptr; 571 mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN); 572 EXPECT_EQ(mgr != nullptr, 1); 573 AppSpawnNamespace *appSpawnNamespace = GetAppSpawnNamespace(mgr); 574 DeleteAppSpawnNamespace(appSpawnNamespace); 575 DeleteAppSpawnMgr(mgr); 576 EXPECT_EQ(appSpawnNamespace == nullptr, 1); 577 578 } 579 580 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_030, TestSize.Level0) 581 { 582 int ret = -1; 583 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_APP_SPAWN); 584 EXPECT_EQ(mgr != nullptr, 1); 585 mgr->content.sandboxNsFlags = 1; 586 ret = PreForkSetPidNamespace(mgr, nullptr); 587 DeleteAppSpawnMgr(mgr); 588 ASSERT_EQ(ret, 0); 589 } 590 591 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_031, TestSize.Level0) 592 { 593 int ret = -1; 594 AppSpawnMgr *mgr = CreateAppSpawnMgr(MODE_FOR_APP_SPAWN); 595 EXPECT_EQ(mgr != nullptr, 1); 596 mgr->content.sandboxNsFlags = 0; 597 ret = PostForkSetPidNamespace(mgr, nullptr); 598 DeleteAppSpawnMgr(mgr); 599 ASSERT_EQ(ret, 0); 600 AppSpawnClientInit(nullptr, nullptr); 601 } 602 603 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_GetAppSpawnNamespace, TestSize.Level0) 604 { 605 int ret = -1; 606 AppSpawnMgr *mgr = nullptr; 607 AppSpawnNamespace *appSpawnNamespace = nullptr; 608 mgr = CreateAppSpawnMgr(MODE_FOR_APP_SPAWN); 609 EXPECT_EQ(mgr != nullptr, 1); 610 appSpawnNamespace = CreateAppSpawnNamespace(); 611 appSpawnNamespace->nsSelfPidFd = GetNsPidFd(getpid()); 612 OH_ListInit(&appSpawnNamespace->extData.node); 613 OH_ListAddTail(&mgr->extData, &appSpawnNamespace->extData.node); 614 AppSpawnNamespace *appSpawnNamespace1 = nullptr; 615 appSpawnNamespace1 = GetAppSpawnNamespace(mgr); 616 EXPECT_EQ(appSpawnNamespace1 != nullptr, 1); 617 uint32_t dataId = EXT_DATA_NAMESPACE; 618 AppSpawnExtDataCompareDataId(&mgr->extData, (void *)&dataId); 619 DeleteAppSpawnNamespace(appSpawnNamespace); 620 DeleteAppSpawnMgr(mgr); 621 } 622 623 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_GetPidByName, TestSize.Level0) 624 { 625 int ret = -1; 626 AppSpawnMgr *mgr = nullptr; 627 AppSpawnNamespace *appSpawnNamespace = nullptr; 628 mgr = CreateAppSpawnMgr(MODE_FOR_APP_SPAWN); 629 EXPECT_EQ(mgr != nullptr, 1); 630 appSpawnNamespace = CreateAppSpawnNamespace(); 631 OH_ListInit(&appSpawnNamespace->extData.node); 632 OH_ListAddTail(&mgr->extData, &appSpawnNamespace->extData.node); 633 appSpawnNamespace->nsInitPidFd = GetNsPidFd(getpid()); 634 pid_t pid = GetPidByName("appspawn"); 635 EXPECT_EQ(pid > 0, 1); 636 DeleteAppSpawnNamespace(appSpawnNamespace); 637 DeleteAppSpawnMgr(mgr); 638 } 639 640 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_PreLoadEnablePidNs, TestSize.Level0) 641 { 642 int ret = -1; 643 AppSpawnMgr *mgr = nullptr; 644 AppSpawnNamespace *appSpawnNamespace = nullptr; 645 mgr = CreateAppSpawnMgr(MODE_FOR_APP_SPAWN); 646 EXPECT_EQ(mgr != nullptr, 1); 647 mgr->content.sandboxNsFlags = CLONE_NEWPID; 648 ret = PreLoadEnablePidNs(mgr); 649 EXPECT_EQ(ret, 0); 650 AppSpawnNamespace *appSpawnNamespace1 = nullptr; 651 appSpawnNamespace1 = GetAppSpawnNamespace(mgr); 652 EXPECT_EQ(appSpawnNamespace1 != nullptr, 1); 653 DeleteAppSpawnNamespace(appSpawnNamespace); 654 DeleteAppSpawnMgr(mgr); 655 SetPidNamespace(0, 0); 656 } 657 658 HWTEST_F(AppSpawnCommonTest, App_Spawn_Common_PreForkSetPidNamespace, TestSize.Level0) 659 { 660 int ret = -1; 661 AppSpawnMgr *mgr = nullptr; 662 AppSpawnNamespace *appSpawnNamespace = nullptr; 663 mgr = CreateAppSpawnMgr(MODE_FOR_APP_SPAWN); 664 EXPECT_EQ(mgr != nullptr, 1); 665 mgr->content.sandboxNsFlags = CLONE_NEWPID; 666 ret = PreLoadEnablePidNs(mgr); 667 EXPECT_EQ(ret, 0); 668 PreForkSetPidNamespace(mgr, nullptr); 669 PostForkSetPidNamespace(mgr, nullptr); 670 mgr->content.sandboxNsFlags = 0; 671 PreForkSetPidNamespace(mgr, nullptr); 672 PostForkSetPidNamespace(mgr, nullptr); 673 DeleteAppSpawnNamespace(appSpawnNamespace); 674 DeleteAppSpawnMgr(mgr); 675 SetPidNamespace(0, 0); 676 } 677 678 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_001, TestSize.Level0) 679 { 680 AppSpawnClientHandle clientHandle = nullptr; 681 AppSpawnReqMsgHandle reqHandle = 0; 682 AppSpawningCtx *property = nullptr; 683 AppSpawnMgr *mgr = nullptr; 684 int ret = -1; 685 do { 686 mgr = CreateAppSpawnMgr(MODE_FOR_APP_SPAWN); 687 EXPECT_EQ(mgr != nullptr, 1); 688 // create msg 689 ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle); 690 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 691 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_APP_SPAWN, 0); 692 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 693 const char *permissions = "{\"name\":\"Permissions\",\"ohos.encaps.count\":6,\"permissions\":" 694 "[{\"ohos.permission.bool\":true},{\"ohos.permission.int\":3225},{\"ohos.permission.string\":\"nihaoma\"}," 695 "{\"ohos.permission.strarray\":[\"abc\",\"def\"]},{\"ohos.permission.intarray\":[1,2,3,4,5]}," 696 "{\"ohos.permission.boolarray\":[true,false,true]}]}"; 697 ret = AppSpawnReqMsgAddExtInfo(reqHandle, MSG_EXT_NAME_JIT_PERMISSIONS, 698 reinterpret_cast<uint8_t *>(const_cast<char *>(permissions)), strlen(permissions) + 1); 699 APPSPAWN_CHECK(ret == 0, break, "Failed to add permissions"); 700 const char *maxChildProcess = "512"; 701 ret = AppSpawnReqMsgAddExtInfo(reqHandle, MSG_EXT_NAME_MAX_CHILD_PROCCESS_MAX, 702 reinterpret_cast<uint8_t *>(const_cast<char *>(maxChildProcess)), strlen(maxChildProcess) + 1); 703 APPSPAWN_CHECK(ret == 0, break, "Failed to add maxChildProcess"); 704 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 705 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 706 707 ret = SpawnSetEncapsPermissions(NULL, property); 708 EXPECT_EQ(ret, APPSPAWN_ARG_INVALID); 709 710 ret = SpawnSetEncapsPermissions(mgr, NULL); 711 EXPECT_EQ(ret, APPSPAWN_ARG_INVALID); 712 713 ret = SpawnSetEncapsPermissions(mgr, property); 714 } while (0); 715 716 EXPECT_EQ(ret, 0); 717 DeleteAppSpawningCtx(property); 718 AppSpawnClientDestroy(clientHandle); 719 DeleteAppSpawnMgr(mgr); 720 } 721 722 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_002, TestSize.Level0) 723 { 724 AppSpawnClientHandle clientHandle = nullptr; 725 AppSpawnReqMsgHandle reqHandle = 0; 726 AppSpawningCtx *property = nullptr; 727 AppSpawnMgr *mgr = nullptr; 728 int ret = -1; 729 do { 730 mgr = CreateAppSpawnMgr(MODE_FOR_APP_SPAWN); 731 EXPECT_EQ(mgr != nullptr, 1); 732 // create msg 733 ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle); 734 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 735 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_APP_SPAWN, 0); 736 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 737 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 738 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 739 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 740 ret = SpawnSetEncapsPermissions(mgr, property); 741 } while (0); 742 743 EXPECT_EQ(ret, 0); 744 DeleteAppSpawningCtx(property); 745 AppSpawnClientDestroy(clientHandle); 746 DeleteAppSpawnMgr(mgr); 747 } 748 749 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_003, TestSize.Level0) 750 { 751 AppSpawnClientHandle clientHandle = nullptr; 752 AppSpawnReqMsgHandle reqHandle = 0; 753 AppSpawningCtx *property = nullptr; 754 UserEncaps encapsInfo = {0}; 755 int ret = -1; 756 do { 757 // create msg 758 ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle); 759 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 760 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_APP_SPAWN, 0); 761 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 762 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 763 const char *permissions = "{\"name\":\"Permissions\",\"ohos.encaps.count\":0,\"permissions\":" 764 "[{\"ohos.permission.bool\":true},{\"ohos.permission.int\":3225},{\"ohos.permission.string\":\"test\"}," 765 "{\"ohos.permission.array\":[1,2,3,4,5]}]}"; 766 ret = AppSpawnReqMsgAddExtInfo(reqHandle, MSG_EXT_NAME_JIT_PERMISSIONS, 767 reinterpret_cast<uint8_t *>(const_cast<char *>(permissions)), strlen(permissions) + 1); 768 APPSPAWN_CHECK(ret == 0, break, "Failed to add permissions"); 769 const char *maxChildProcess = "512"; 770 ret = AppSpawnReqMsgAddExtInfo(reqHandle, MSG_EXT_NAME_MAX_CHILD_PROCCESS_MAX, 771 reinterpret_cast<uint8_t *>(const_cast<char *>(maxChildProcess)), strlen(maxChildProcess) + 1); 772 APPSPAWN_CHECK(ret == 0, break, "Failed to add maxChildProcess"); 773 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 774 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 775 ret = SpawnSetPermissions(property, &encapsInfo); 776 } while (0); 777 778 EXPECT_EQ(ret, APPSPAWN_ARG_INVALID); 779 DeleteAppSpawningCtx(property); 780 AppSpawnClientDestroy(clientHandle); 781 FreeEncapsInfo(&encapsInfo); 782 } 783 784 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_004, TestSize.Level0) 785 { 786 AppSpawnClientHandle clientHandle = nullptr; 787 AppSpawnReqMsgHandle reqHandle = 0; 788 AppSpawningCtx *property = nullptr; 789 UserEncaps encapsInfo = {0}; 790 int ret = -1; 791 do { 792 // create msg 793 ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle); 794 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 795 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_APP_SPAWN, 0); 796 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 797 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 798 const char *permissions = "{\"name\":\"Permissions\",\"ohos.encaps.count\":2,\"permissions\":" 799 "[{\"ohos.permission.bool\":true},{\"ohos.permission.int\":3225}]}"; 800 ret = AppSpawnReqMsgAddExtInfo(reqHandle, MSG_EXT_NAME_JIT_PERMISSIONS, 801 reinterpret_cast<uint8_t *>(const_cast<char *>(permissions)), strlen(permissions) + 1); 802 APPSPAWN_CHECK(ret == 0, break, "Failed to add permissions"); 803 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 804 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 805 ret = SpawnSetPermissions(property, &encapsInfo); 806 } while (0); 807 808 EXPECT_EQ(ret, 0); 809 EXPECT_EQ(encapsInfo.encapsCount, 2); 810 DeleteAppSpawningCtx(property); 811 AppSpawnClientDestroy(clientHandle); 812 FreeEncapsInfo(&encapsInfo); 813 } 814 815 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_005, TestSize.Level0) 816 { 817 UserEncaps encapsInfo = {0}; 818 int ret = AddMembersToEncapsInfo(NULL, &encapsInfo); 819 EXPECT_EQ(ret, APPSPAWN_ARG_INVALID); 820 } 821 822 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_006, TestSize.Level0) 823 { 824 const char encapsJsonStr[] = "{\"name\":\"Permissions\",\"ohos.encaps.count\":5,\"permissions\":" 825 "[{\"ohos.permission.bool\":true},{\"ohos.permission.int\":3225},{\"ohos.permission.string\":\"test\"}," 826 "{\"ohos.permission.array\":[1,2,3,4,5]}]}"; 827 828 cJSON *encapsJson = cJSON_Parse(encapsJsonStr); 829 EXPECT_NE(encapsJson, nullptr); 830 cJSON *permissions = cJSON_GetObjectItemCaseSensitive(encapsJson, "permissions"); 831 EXPECT_NE(permissions, nullptr); 832 cJSON *emptyItem = cJSON_CreateObject(); 833 EXPECT_TRUE(cJSON_AddItemToArray(permissions, emptyItem)); 834 UserEncaps encapsInfo = {0}; 835 int ret = AddMembersToEncapsInfo(encapsJson, &encapsInfo); 836 EXPECT_EQ(ret, APPSPAWN_ERROR_UTILS_DECODE_JSON_FAIL); 837 838 cJSON_Delete(encapsJson); 839 FreeEncapsInfo(&encapsInfo); 840 } 841 842 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_007, TestSize.Level0) 843 { 844 const char encapsJsonStr[] = "{\"name\":\"Permissions\",\"ohos.encaps.count\":4,\"permissions\":" 845 "[{\"ohos.permission.bool\":true},{\"ohos.permission.int\":3225},{\"ohos.permission.string\":\"test\"}," 846 "{\"ohos.permission.array\":[1,\"abc\",3,4,5]}]}"; 847 848 cJSON *encapsJson = cJSON_Parse(encapsJsonStr); 849 EXPECT_NE(encapsJson, nullptr); 850 UserEncaps encapsInfo = {0}; 851 int ret = AddMembersToEncapsInfo(encapsJson, &encapsInfo); 852 EXPECT_EQ(ret, APPSPAWN_ERROR_UTILS_ADD_JSON_FAIL); 853 854 cJSON_Delete(encapsJson); 855 FreeEncapsInfo(&encapsInfo); 856 } 857 858 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_008, TestSize.Level0) 859 { 860 const char permissionItemStr[] = "{\"ohos.permission.bool\":true}"; 861 862 cJSON *permissionItem = cJSON_Parse(permissionItemStr); 863 EXPECT_NE(permissionItem, nullptr); 864 UserEncap encap; 865 (void)memset_s(&encap, sizeof(encap), 0, sizeof(encap)); 866 // permissionItem->string is NULL 867 int ret = AddPermissionItemToEncapsInfo(&encap, permissionItem); 868 EXPECT_EQ(ret, APPSPAWN_SYSTEM_ERROR); 869 870 cJSON_Delete(permissionItem); 871 } 872 873 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_009, TestSize.Level0) 874 { 875 // len = 512 + "\0" 876 const char permissionItemStr[] = "{\"ohos.permission.string\":\"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 877 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 878 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 879 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 880 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 881 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\"}"; 882 883 cJSON *permissionItem = cJSON_Parse(permissionItemStr); 884 EXPECT_NE(permissionItem, nullptr); 885 cJSON *permissionChild = permissionItem->child; 886 EXPECT_NE(permissionChild, nullptr); 887 UserEncap encap; 888 (void)memset_s(&encap, sizeof(encap), 0, sizeof(encap)); 889 int ret = AddPermissionItemToEncapsInfo(&encap, permissionChild); 890 EXPECT_EQ(ret, APPSPAWN_ARG_INVALID); 891 892 cJSON_Delete(permissionItem); 893 } 894 895 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_010, TestSize.Level0) 896 { 897 const char permissionItemStr[] = "{\"ohos.permission.strarray\":[\"abc\",\"def\",1]}"; 898 899 cJSON *permissionItem = cJSON_Parse(permissionItemStr); 900 EXPECT_NE(permissionItem, nullptr); 901 cJSON *permissionChild = permissionItem->child; 902 EXPECT_NE(permissionChild, nullptr); 903 UserEncap encap; 904 (void)memset_s(&encap, sizeof(encap), 0, sizeof(encap)); 905 int ret = AddPermissionItemToEncapsInfo(&encap, permissionChild); 906 EXPECT_EQ(ret, APPSPAWN_ARG_INVALID); 907 908 cJSON_Delete(permissionItem); 909 } 910 911 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_011, TestSize.Level0) 912 { 913 const char permissionItemStr[] = "{\"ohos.permission.boolarray\":[true,false,\"abc\"]}"; 914 915 cJSON *permissionItem = cJSON_Parse(permissionItemStr); 916 EXPECT_NE(permissionItem, nullptr); 917 cJSON *permissionChild = permissionItem->child; 918 EXPECT_NE(permissionChild, nullptr); 919 UserEncap encap; 920 (void)memset_s(&encap, sizeof(encap), 0, sizeof(encap)); 921 int ret = AddPermissionItemToEncapsInfo(&encap, permissionChild); 922 EXPECT_EQ(ret, APPSPAWN_ARG_INVALID); 923 924 cJSON_Delete(permissionItem); 925 } 926 927 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_012, TestSize.Level0) 928 { 929 const char permissionItemStr[] = "{\"ohos.permission.intarray\":[1,2,3,4,false]}"; 930 931 cJSON *permissionItem = cJSON_Parse(permissionItemStr); 932 EXPECT_NE(permissionItem, nullptr); 933 cJSON *permissionChild = permissionItem->child; 934 EXPECT_NE(permissionChild, nullptr); 935 UserEncap encap; 936 (void)memset_s(&encap, sizeof(encap), 0, sizeof(encap)); 937 int ret = AddPermissionItemToEncapsInfo(&encap, permissionChild); 938 EXPECT_EQ(ret, APPSPAWN_ARG_INVALID); 939 940 cJSON_Delete(permissionItem); 941 } 942 943 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_013, TestSize.Level0) 944 { 945 // array len = 510 + "\0" * 3 946 const char permissionItemStr[] = "{\"ohos.permission.strarray\":[\"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 947 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 948 "\",\"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 949 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 950 "AAAA\",\"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 951 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\"]}"; 952 953 cJSON *permissionItem = cJSON_Parse(permissionItemStr); 954 EXPECT_NE(permissionItem, nullptr); 955 cJSON *permissionChild = permissionItem->child; 956 EXPECT_NE(permissionChild, nullptr); 957 UserEncap encap; 958 (void)memset_s(&encap, sizeof(encap), 0, sizeof(encap)); 959 int ret = AddPermissionItemToEncapsInfo(&encap, permissionChild); 960 EXPECT_EQ(ret, APPSPAWN_ARG_INVALID); 961 962 cJSON_Delete(permissionItem); 963 } 964 965 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_014, TestSize.Level0) 966 { 967 // array len = 509 + "\0" * 3 968 const char permissionItemStr[] = "{\"ohos.permission.strarray\":[\"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 969 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 970 "\",\"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 971 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 972 "AAAA\",\"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 973 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\"]}"; 974 975 cJSON *permissionItem = cJSON_Parse(permissionItemStr); 976 EXPECT_NE(permissionItem, nullptr); 977 cJSON *permissionChild = permissionItem->child; 978 EXPECT_NE(permissionChild, nullptr); 979 UserEncap encap; 980 (void)memset_s(&encap, sizeof(encap), 0, sizeof(encap)); 981 int ret = AddPermissionItemToEncapsInfo(&encap, permissionChild); 982 EXPECT_EQ(ret, 0); 983 EXPECT_EQ(encap.valueLen, 512); 984 EXPECT_EQ(encap.type, ENCAPS_CHAR_ARRAY); 985 986 cJSON_Delete(permissionItem); 987 } 988 989 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_015, TestSize.Level0) 990 { 991 // key len = 64 + "\0" 992 const char permissionItemStr[] = "{\"ohos.permission.strarrayabcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaa\":\"abc\"}"; 993 994 cJSON *permissionItem = cJSON_Parse(permissionItemStr); 995 EXPECT_NE(permissionItem, nullptr); 996 cJSON *permissionChild = permissionItem->child; 997 EXPECT_NE(permissionChild, nullptr); 998 UserEncap encap; 999 (void)memset_s(&encap, sizeof(encap), 0, sizeof(encap)); 1000 int ret = AddPermissionItemToEncapsInfo(&encap, permissionChild); 1001 EXPECT_EQ(ret, APPSPAWN_SYSTEM_ERROR); 1002 1003 cJSON_Delete(permissionItem); 1004 } 1005 1006 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_016, TestSize.Level0) 1007 { 1008 // key len = 63 + "\0" 1009 const char permissionItemStr[] = "{\"ohos.permission.strarrayabcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaa\":\"abc\"}"; 1010 1011 cJSON *permissionItem = cJSON_Parse(permissionItemStr); 1012 EXPECT_NE(permissionItem, nullptr); 1013 cJSON *permissionChild = permissionItem->child; 1014 EXPECT_NE(permissionChild, nullptr); 1015 UserEncap encap; 1016 (void)memset_s(&encap, sizeof(encap), 0, sizeof(encap)); 1017 int ret = AddPermissionItemToEncapsInfo(&encap, permissionChild); 1018 EXPECT_EQ(ret, 0); 1019 1020 cJSON_Delete(permissionItem); 1021 } 1022 1023 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_017, TestSize.Level0) 1024 { 1025 const char permissionItemStr[] = "{\"ohos.permission.int\":128}"; 1026 1027 cJSON *permissionItem = cJSON_Parse(permissionItemStr); 1028 EXPECT_NE(permissionItem, nullptr); 1029 cJSON *permissionChild = permissionItem->child; 1030 EXPECT_NE(permissionChild, nullptr); 1031 UserEncap encap; 1032 (void)memset_s(&encap, sizeof(encap), 0, sizeof(encap)); 1033 int ret = AddPermissionItemToEncapsInfo(&encap, permissionChild); 1034 EXPECT_EQ(ret, 0); 1035 EXPECT_EQ(encap.type, ENCAPS_INT); 1036 EXPECT_EQ(encap.value.intValue, 128); 1037 1038 cJSON_Delete(permissionItem); 1039 } 1040 1041 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_018, TestSize.Level0) 1042 { 1043 const char permissionItemStr[] = "{\"ohos.permission.bool\":true}"; 1044 1045 cJSON *permissionItem = cJSON_Parse(permissionItemStr); 1046 EXPECT_NE(permissionItem, nullptr); 1047 cJSON *permissionChild = permissionItem->child; 1048 EXPECT_NE(permissionChild, nullptr); 1049 UserEncap encap; 1050 (void)memset_s(&encap, sizeof(encap), 0, sizeof(encap)); 1051 int ret = AddPermissionItemToEncapsInfo(&encap, permissionChild); 1052 EXPECT_EQ(ret, 0); 1053 EXPECT_EQ(encap.type, ENCAPS_BOOL); 1054 EXPECT_EQ(encap.value.intValue, 1); 1055 1056 cJSON_Delete(permissionItem); 1057 } 1058 1059 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_019, TestSize.Level0) 1060 { 1061 const char encapsJsonStr[] = "{\"name\":\"Permissions\",\"ohos.encaps.count\":6,\"permissions\":100}"; 1062 1063 cJSON *encapsJson = cJSON_Parse(encapsJsonStr); 1064 EXPECT_NE(encapsJson, nullptr); 1065 UserEncaps encapsInfo = {0}; 1066 int ret = AddMembersToEncapsInfo(encapsJson, &encapsInfo); 1067 EXPECT_EQ(ret, APPSPAWN_ARG_INVALID); 1068 1069 cJSON_Delete(encapsJson); 1070 FreeEncapsInfo(&encapsInfo); 1071 } 1072 1073 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_020, TestSize.Level0) 1074 { 1075 const char encapsJsonStr[] = "{\"name\":\"Permissions\",\"ohos.encaps.count\":\"6\",\"permissions\":" 1076 "[{\"ohos.permission.bool\":true},{\"ohos.permission.int\":3225},{\"ohos.permission.string\":\"nihaoma\"}," 1077 "{\"ohos.permission.strarray\":[\"abc\",\"def\"]},{\"ohos.permission.intarray\":[1,2,3,4,5]}," 1078 "{\"ohos.permission.boolarray\":[true,false,true]}]}"; 1079 1080 cJSON *encapsJson = cJSON_Parse(encapsJsonStr); 1081 EXPECT_NE(encapsJson, nullptr); 1082 UserEncaps encapsInfo = {0}; 1083 int ret = AddMembersToEncapsInfo(encapsJson, &encapsInfo); 1084 EXPECT_EQ(ret, APPSPAWN_ARG_INVALID); 1085 1086 cJSON_Delete(encapsJson); 1087 FreeEncapsInfo(&encapsInfo); 1088 } 1089 1090 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_021, TestSize.Level0) 1091 { 1092 const char permissionItemStr[] = "{\"ohos.permission.intarray\":[]}"; 1093 1094 cJSON *permissionItem = cJSON_Parse(permissionItemStr); 1095 EXPECT_NE(permissionItem, nullptr); 1096 cJSON *permissionChild = permissionItem->child; 1097 EXPECT_NE(permissionChild, nullptr); 1098 UserEncap encap; 1099 (void)memset_s(&encap, sizeof(encap), 0, sizeof(encap)); 1100 int ret = AddPermissionItemToEncapsInfo(&encap, permissionChild); 1101 EXPECT_EQ(ret, APPSPAWN_ARG_INVALID); 1102 1103 cJSON_Delete(permissionItem); 1104 } 1105 1106 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_022, TestSize.Level0) 1107 { 1108 const char permissionItemStr[] = "{\"ohos.permission.strarray\":[\"abc\",\"\",\"def\"]}"; 1109 1110 cJSON *permissionItem = cJSON_Parse(permissionItemStr); 1111 EXPECT_NE(permissionItem, nullptr); 1112 cJSON *permissionChild = permissionItem->child; 1113 EXPECT_NE(permissionChild, nullptr); 1114 UserEncap encap; 1115 (void)memset_s(&encap, sizeof(encap), 0, sizeof(encap)); 1116 int ret = AddPermissionItemToEncapsInfo(&encap, permissionChild); 1117 EXPECT_EQ(ret, APPSPAWN_ARG_INVALID); 1118 1119 cJSON_Delete(permissionItem); 1120 } 1121 1122 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_023, TestSize.Level0) 1123 { 1124 const char permissionItemStr[] = "{\"ohos.permission.str\":\"\"}"; 1125 1126 cJSON *permissionItem = cJSON_Parse(permissionItemStr); 1127 EXPECT_NE(permissionItem, nullptr); 1128 cJSON *permissionChild = permissionItem->child; 1129 EXPECT_NE(permissionChild, nullptr); 1130 UserEncap encap; 1131 (void)memset_s(&encap, sizeof(encap), 0, sizeof(encap)); 1132 int ret = AddPermissionItemToEncapsInfo(&encap, permissionChild); 1133 EXPECT_EQ(ret, APPSPAWN_ARG_INVALID); 1134 1135 cJSON_Delete(permissionItem); 1136 } 1137 1138 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_024, TestSize.Level0) 1139 { 1140 const char permissionItemStr[] = "[1,2,3,4,5]"; 1141 1142 cJSON *permissionItem = cJSON_Parse(permissionItemStr); 1143 EXPECT_NE(permissionItem, nullptr); 1144 cJSON *permissionChild = permissionItem->child; 1145 EXPECT_NE(permissionChild, nullptr); 1146 UserEncap encap; 1147 (void)memset_s(&encap, sizeof(encap), 0, sizeof(encap)); 1148 int ret = AddPermissionIntArrayToValue(permissionChild, &encap, 6); 1149 EXPECT_EQ(ret, APPSPAWN_ARG_INVALID); 1150 1151 cJSON_Delete(permissionItem); 1152 } 1153 1154 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_025, TestSize.Level0) 1155 { 1156 const char permissionItemStr[] = "[true,false,true]"; 1157 1158 cJSON *permissionItem = cJSON_Parse(permissionItemStr); 1159 EXPECT_NE(permissionItem, nullptr); 1160 cJSON *permissionChild = permissionItem->child; 1161 EXPECT_NE(permissionChild, nullptr); 1162 UserEncap encap; 1163 (void)memset_s(&encap, sizeof(encap), 0, sizeof(encap)); 1164 int ret = AddPermissionBoolArrayToValue(permissionChild, &encap, 4); 1165 EXPECT_EQ(ret, APPSPAWN_ARG_INVALID); 1166 1167 cJSON_Delete(permissionItem); 1168 } 1169 1170 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_026, TestSize.Level0) 1171 { 1172 const char permissionItemStr[] = "[\"abc\",\"def\"]"; 1173 1174 cJSON *permissionItem = cJSON_Parse(permissionItemStr); 1175 EXPECT_NE(permissionItem, nullptr); 1176 cJSON *item = cJSON_CreateString(""); 1177 EXPECT_NE(item, nullptr); 1178 free(item->valuestring); 1179 item->valuestring = nullptr; 1180 EXPECT_EQ(cJSON_AddItemToArray(permissionItem, item), 1); 1181 cJSON *permissionChild = permissionItem->child; 1182 EXPECT_NE(permissionChild, nullptr); 1183 UserEncap encap; 1184 (void)memset_s(&encap, sizeof(encap), 0, sizeof(encap)); 1185 int ret = AddPermissionStrArrayToValue(permissionChild, &encap); 1186 EXPECT_EQ(ret, APPSPAWN_ARG_INVALID); 1187 1188 cJSON_Delete(permissionItem); 1189 } 1190 1191 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_027, TestSize.Level0) 1192 { 1193 const char permissionItemStr[] = "{\"ohos.permission.intarray\":[{\"ohos.permission.bool\":true},2,3,4,5]}"; 1194 1195 cJSON *permissionItem = cJSON_Parse(permissionItemStr); 1196 EXPECT_NE(permissionItem, nullptr); 1197 cJSON *permissionChild = permissionItem->child; 1198 UserEncap encap; 1199 (void)memset_s(&encap, sizeof(encap), 0, sizeof(encap)); 1200 int ret = AddPermissionArrayToValue(permissionChild, &encap); 1201 EXPECT_EQ(ret, APPSPAWN_ARG_INVALID); 1202 1203 cJSON_Delete(permissionItem); 1204 } 1205 1206 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_028, TestSize.Level0) 1207 { 1208 const char permissionItemStr[] = "{\"permissions\":{\"ohos.permission.bool\":true}}"; 1209 1210 cJSON *permissionItem = cJSON_Parse(permissionItemStr); 1211 EXPECT_NE(permissionItem, nullptr); 1212 cJSON *permissionChild = permissionItem->child; 1213 EXPECT_NE(permissionChild, nullptr); 1214 UserEncap encap; 1215 (void)memset_s(&encap, sizeof(encap), 0, sizeof(encap)); 1216 int ret = AddPermissionItemToEncapsInfo(&encap, permissionChild); 1217 EXPECT_EQ(ret, APPSPAWN_ARG_INVALID); 1218 1219 cJSON_Delete(permissionItem); 1220 } 1221 1222 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_029, TestSize.Level0) 1223 { 1224 const char encapsJsonStr[] = "{\"name\":\"Permissions\",\"ohos.encaps.count\":6,\"permissions\":[]}"; 1225 1226 cJSON *encapsJson = cJSON_Parse(encapsJsonStr); 1227 EXPECT_NE(encapsJson, nullptr); 1228 UserEncaps encapsInfo = {0}; 1229 int ret = AddMembersToEncapsInfo(encapsJson, &encapsInfo); 1230 EXPECT_EQ(ret, APPSPAWN_ARG_INVALID); 1231 1232 cJSON_Delete(encapsJson); 1233 FreeEncapsInfo(&encapsInfo); 1234 } 1235 1236 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_030, TestSize.Level0) 1237 { 1238 AppSpawnClientHandle clientHandle = nullptr; 1239 AppSpawnReqMsgHandle reqHandle = 0; 1240 AppSpawningCtx *property = nullptr; 1241 UserEncaps encapsInfo = {0}; 1242 int ret = -1; 1243 do { 1244 // create msg 1245 ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle); 1246 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 1247 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0); 1248 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 1249 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 1250 const char *permissions = "{\"name\":\"Permissions\",\"ohos.encaps.count\":4,\"permissions\":" 1251 "[{\"ohos.permission.bool\":true},{\"ohos.permission.int\":3225},{\"ohos.permission.string\":\"test\"}," 1252 "{\"ohos.permission.array\":[1,2,3,4,5]}]}"; 1253 ret = AppSpawnReqMsgAddExtInfo(reqHandle, MSG_EXT_NAME_JIT_PERMISSIONS, 1254 reinterpret_cast<uint8_t *>(const_cast<char *>(permissions)), strlen(permissions) + 1); 1255 APPSPAWN_CHECK(ret == 0, break, "Failed to add permissions"); 1256 const char *maxChildProcess = "512"; 1257 ret = AppSpawnReqMsgAddExtInfo(reqHandle, MSG_EXT_NAME_MAX_CHILD_PROCCESS_MAX, 1258 reinterpret_cast<uint8_t *>(const_cast<char *>(maxChildProcess)), strlen(maxChildProcess) + 1); 1259 APPSPAWN_CHECK(ret == 0, break, "Failed to add maxChildProcess"); 1260 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 1261 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 1262 ret = SpawnSetPermissions(property, &encapsInfo); 1263 } while (0); 1264 1265 EXPECT_EQ(ret, 0); 1266 EXPECT_EQ(encapsInfo.encapsCount, 4); 1267 DeleteAppSpawningCtx(property); 1268 AppSpawnClientDestroy(clientHandle); 1269 FreeEncapsInfo(&encapsInfo); 1270 } 1271 1272 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_031, TestSize.Level0) 1273 { 1274 AppSpawnClientHandle clientHandle = nullptr; 1275 AppSpawnReqMsgHandle reqHandle = 0; 1276 AppSpawningCtx *property = nullptr; 1277 UserEncaps encapsInfo = {0}; 1278 int ret = -1; 1279 do { 1280 // create msg 1281 ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle); 1282 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 1283 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_APP_SPAWN, 0); 1284 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 1285 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 1286 const char *permissions = "{\"name\":\"Permissions\",\"ohos.encaps.count\":4,\"permissions\":" 1287 "[{\"ohos.permission.bool\":true},{\"ohos.permission.int\":3225},{\"ohos.permission.string\":\"test\"}," 1288 "{\"ohos.permission.array\":[1,2,3,4,5]}]}"; 1289 ret = AppSpawnReqMsgAddExtInfo(reqHandle, MSG_EXT_NAME_JIT_PERMISSIONS, 1290 reinterpret_cast<uint8_t *>(const_cast<char *>(permissions)), strlen(permissions) + 1); 1291 APPSPAWN_CHECK(ret == 0, break, "Failed to add permissions"); 1292 const char *maxChildProcess = "0"; 1293 ret = AppSpawnReqMsgAddExtInfo(reqHandle, MSG_EXT_NAME_MAX_CHILD_PROCCESS_MAX, 1294 reinterpret_cast<uint8_t *>(const_cast<char *>(maxChildProcess)), strlen(maxChildProcess) + 1); 1295 APPSPAWN_CHECK(ret == 0, break, "Failed to add maxChildProcess"); 1296 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 1297 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 1298 ret = SpawnSetPermissions(property, &encapsInfo); 1299 } while (0); 1300 1301 EXPECT_EQ(ret, 0); 1302 EXPECT_EQ(encapsInfo.encapsCount, 4); 1303 DeleteAppSpawningCtx(property); 1304 AppSpawnClientDestroy(clientHandle); 1305 FreeEncapsInfo(&encapsInfo); 1306 } 1307 1308 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_032, TestSize.Level0) 1309 { 1310 AppSpawnClientHandle clientHandle = nullptr; 1311 AppSpawnReqMsgHandle reqHandle = 0; 1312 AppSpawningCtx *property = nullptr; 1313 AppSpawnMgr *mgr = nullptr; 1314 int ret = -1; 1315 do { 1316 mgr = CreateAppSpawnMgr(MODE_FOR_HYBRID_SPAWN); 1317 EXPECT_EQ(mgr != nullptr, 1); 1318 // create msg 1319 ret = AppSpawnClientInit(HYBRIDSPAWN_SERVER_NAME, &clientHandle); 1320 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", HYBRIDSPAWN_SERVER_NAME); 1321 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_APP_SPAWN, 0); 1322 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, "Failed to create req %{public}s", 1323 HYBRIDSPAWN_SERVER_NAME); 1324 const char *permissions = "{\"name\":\"Permissions\",\"ohos.encaps.count\":6,\"permissions\":" 1325 "[{\"ohos.permission.bool\":true},{\"ohos.permission.int\":3225},{\"ohos.permission.string\":\"nihaoma\"}," 1326 "{\"ohos.permission.strarray\":[\"abc\",\"def\"]},{\"ohos.permission.intarray\":[1,2,3,4,5]}," 1327 "{\"ohos.permission.boolarray\":[true,false,true]}]}"; 1328 ret = AppSpawnReqMsgAddExtInfo(reqHandle, MSG_EXT_NAME_JIT_PERMISSIONS, 1329 reinterpret_cast<uint8_t *>(const_cast<char *>(permissions)), strlen(permissions) + 1); 1330 APPSPAWN_CHECK(ret == 0, break, "Failed to add permissions"); 1331 const char *maxChildProcess = "512"; 1332 ret = AppSpawnReqMsgAddExtInfo(reqHandle, MSG_EXT_NAME_MAX_CHILD_PROCCESS_MAX, 1333 reinterpret_cast<uint8_t *>(const_cast<char *>(maxChildProcess)), strlen(maxChildProcess) + 1); 1334 APPSPAWN_CHECK(ret == 0, break, "Failed to add maxChildProcess"); 1335 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 1336 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 1337 1338 ret = SpawnSetEncapsPermissions(mgr, property); 1339 } while (0); 1340 1341 EXPECT_EQ(ret, 0); 1342 DeleteAppSpawningCtx(property); 1343 AppSpawnClientDestroy(clientHandle); 1344 DeleteAppSpawnMgr(mgr); 1345 } 1346 1347 HWTEST_F(AppSpawnCommonTest, App_Spawn_Encaps_033, TestSize.Level0) 1348 { 1349 AppSpawnClientHandle clientHandle = nullptr; 1350 AppSpawnReqMsgHandle reqHandle = 0; 1351 AppSpawningCtx *property = nullptr; 1352 AppSpawnMgr *mgr = nullptr; 1353 int ret = -1; 1354 do { 1355 mgr = CreateAppSpawnMgr(MODE_FOR_HYBRID_SPAWN); 1356 EXPECT_EQ(mgr != nullptr, 1); 1357 // create msg 1358 ret = AppSpawnClientInit(HYBRIDSPAWN_SERVER_NAME, &clientHandle); 1359 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", HYBRIDSPAWN_SERVER_NAME); 1360 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_APP_SPAWN, 0); 1361 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 1362 "Failed to create req %{public}s", HYBRIDSPAWN_SERVER_NAME); 1363 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 1364 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 1365 ret = SpawnSetEncapsPermissions(mgr, property); 1366 } while (0); 1367 1368 EXPECT_EQ(ret, 0); 1369 DeleteAppSpawningCtx(property); 1370 AppSpawnClientDestroy(clientHandle); 1371 DeleteAppSpawnMgr(mgr); 1372 } 1373 1374 HWTEST_F(AppSpawnCommonTest, App_Spawn_SetFdEnv, TestSize.Level0) 1375 { 1376 int ret = SetFdEnv(nullptr, nullptr); 1377 EXPECT_EQ(ret, -1); 1378 1379 AppSpawningCtx property; 1380 ret = SetFdEnv(nullptr, &property); 1381 EXPECT_EQ(ret, -1); // message == null 1382 1383 property.message = (AppSpawnMsgNode *)malloc(sizeof(AppSpawnMsgNode) + sizeof(AppSpawnMsgNode) + APP_LEN_PROC_NAME); 1384 ASSERT_EQ(property.message != nullptr, 1); 1385 AppSpawnConnection *connection = (AppSpawnConnection *)malloc(sizeof(AppSpawnConnection)); 1386 ASSERT_EQ(connection != nullptr, 1); 1387 uint8_t *buffer = (uint8_t*)malloc(sizeof(uint8_t) * 10); 1388 ASSERT_EQ(buffer != nullptr, 1); 1389 1390 property.message->buffer = nullptr; 1391 property.message->connection = nullptr; 1392 ret = SetFdEnv(nullptr, &property); 1393 EXPECT_EQ(ret, -1); // message != null, message->buffer == null, message->connection == null 1394 1395 property.message->buffer = nullptr; 1396 property.message->connection = connection; 1397 ret = SetFdEnv(nullptr, &property); // message != null, message->connection != null, message->buffer == null 1398 EXPECT_EQ(ret, -1); 1399 1400 property.message->buffer = buffer; 1401 property.message->connection = nullptr; 1402 ret = SetFdEnv(nullptr, &property); // message != null, message->connection == null, message->buffer != null 1403 EXPECT_EQ(ret, -1); 1404 1405 free(buffer); 1406 free(connection); 1407 free(property.message); 1408 } 1409 1410 HWTEST_F(AppSpawnCommonTest, App_Spawn_SetIsolateDir, TestSize.Level0) 1411 { 1412 AppSpawnClientHandle clientHandle = nullptr; 1413 AppSpawnReqMsgHandle reqHandle = 0; 1414 AppSpawningCtx *property = nullptr; 1415 int ret = -1; 1416 do { 1417 // create msg 1418 ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle); 1419 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 1420 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_APP_SPAWN, 0); 1421 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 1422 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 1423 // set custom sandbox flag 1424 ret = AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_CUSTOM_SANDBOX); 1425 APPSPAWN_CHECK_ONLY_EXPER(ret == 0, break); 1426 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 1427 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 1428 ret = SetIsolateDir(property); 1429 } while (0); 1430 DeleteAppSpawningCtx(property); 1431 AppSpawnClientDestroy(clientHandle); 1432 ASSERT_EQ(ret, 0); 1433 } 1434 1435 #ifdef APPSPAWN_HITRACE_OPTION 1436 HWTEST_F(AppSpawnCommonTest, App_Spawn_FilterAppSpawnTrace, TestSize.Level0) 1437 { 1438 AppSpawnClientHandle clientHandle = nullptr; 1439 AppSpawnReqMsgHandle reqHandle = 0; 1440 AppSpawningCtx *property = nullptr; 1441 int ret = -1; 1442 FilterAppSpawnTrace(nullptr, property); 1443 EXPECT_EQ(property, nullptr); 1444 1445 do { 1446 ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle); 1447 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", APPSPAWN_SERVER_NAME); 1448 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_APP_SPAWN, 0); 1449 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 1450 "Failed to create req %{public}s", APPSPAWN_SERVER_NAME); 1451 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 1452 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 1453 FilterAppSpawnTrace(nullptr, property); 1454 } while (0); 1455 1456 DeleteAppSpawningCtx(property); 1457 AppSpawnClientDestroy(clientHandle); 1458 } 1459 #endif 1460 1461 HWTEST_F(AppSpawnCommonTest, App_Spawn_SetCapabilities, TestSize.Level0) 1462 { 1463 AppSpawnClientHandle clientHandle = nullptr; 1464 AppSpawnReqMsgHandle reqHandle = 0; 1465 AppSpawningCtx *property = nullptr; 1466 AppSpawnMgr *mgr = nullptr; 1467 int ret = -1; 1468 do { 1469 mgr = CreateAppSpawnMgr(MODE_FOR_NWEB_SPAWN); 1470 EXPECT_EQ(mgr != nullptr, 1); 1471 // create msg 1472 ret = AppSpawnClientInit(NWEBSPAWN_SERVER_NAME, &clientHandle); 1473 APPSPAWN_CHECK(ret == 0, break, "Failed to create reqMgr %{public}s", NWEBSPAWN_SERVER_NAME); 1474 reqHandle = g_testHelper.CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0); 1475 APPSPAWN_CHECK(reqHandle != INVALID_REQ_HANDLE, break, 1476 "Failed to create req %{public}s", NWEBSPAWN_SERVER_NAME); 1477 property = g_testHelper.GetAppProperty(clientHandle, reqHandle); 1478 APPSPAWN_CHECK_ONLY_EXPER(property != nullptr, break); 1479 ret = SetCapabilities(mgr, property); 1480 } while (0); 1481 DeleteAppSpawningCtx(property); 1482 AppSpawnClientDestroy(clientHandle); 1483 DeleteAppSpawnMgr(mgr); 1484 ASSERT_EQ(ret, 0); 1485 } 1486 } // namespace OHOS 1487