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 #include <cerrno>
16 #include <cstdlib>
17 #include <cstring>
18 #include <memory>
19 #include <string>
20 #include <thread>
21 #include <unistd.h>
22 
23 #include <gtest/gtest.h>
24 #include <sys/stat.h>
25 #include <sys/types.h>
26 
27 #include "appspawn_adapter.h"
28 #include "appspawn_manager.h"
29 #include "appspawn_modulemgr.h"
30 #include "appspawn_server.h"
31 #include "json_utils.h"
32 #include "parameter.h"
33 #include "securec.h"
34 #include "cJSON.h"
35 
36 #include "app_spawn_stub.h"
37 #include "app_spawn_test_helper.h"
38 
39 using namespace testing;
40 using namespace testing::ext;
41 using namespace OHOS;
42 
43 namespace OHOS {
44 class AppSpawnServiceTest : public testing::Test {
45 public:
SetUpTestCase()46     static void SetUpTestCase() {}
TearDownTestCase()47     static void TearDownTestCase() {}
SetUp()48     void SetUp()
49     {
50         testServer = std::make_unique<OHOS::AppSpawnTestServer>("appspawn -mode appspawn");
51         if (testServer != nullptr) {
52             testServer->Start(nullptr);
53         }
54     }
TearDown()55     void TearDown()
56     {
57         if (testServer != nullptr) {
58             testServer->Stop();
59         }
60     }
61 public:
62     std::unique_ptr<OHOS::AppSpawnTestServer> testServer = nullptr;
63 };
64 
65 /**
66  * @brief 正常消息发送和接收，完整应用孵化过程
67  *
68  */
69 HWTEST_F(AppSpawnServiceTest, App_Spawn_001, TestSize.Level0)
70 {
71     int ret = 0;
72     AppSpawnClientHandle clientHandle = nullptr;
73     do {
74         APPSPAWN_LOGV("App_Spawn_001 start");
75         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
76         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
77         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
78 
79         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_NO_SANDBOX);
80         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_DEBUGGABLE);
81         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_NATIVEDEBUG);
82         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_BUNDLE_RESOURCES);
83         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_ACCESS_BUNDLE_DIR);
84 
85         AppSpawnResult result = {};
86         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
87         APPSPAWN_LOGV("App_Spawn_001 recv result %{public}d  %{public}d", result.result, result.pid);
88         APPSPAWN_CHECK(ret == 0, break, "Failed to send msg %{public}d", ret);
89         if (ret == 0 && result.pid > 0) {
90             APPSPAWN_LOGV("App_Spawn_001 Kill pid %{public}d ", result.pid);
91             DumpSpawnStack(result.pid);
92             kill(result.pid, SIGKILL);
93         }
94     } while (0);
95 
96     AppSpawnClientDestroy(clientHandle);
97     ASSERT_EQ(ret, 0);
98 }
99 
100 /**
101  * @brief 模拟测试，孵化进程退出后，MSG_GET_RENDER_TERMINATION_STATUS
102  *
103  */
104 HWTEST_F(AppSpawnServiceTest, App_Spawn_002, TestSize.Level0)
105 {
106     int ret = 0;
107     AppSpawnClientHandle clientHandle = nullptr;
108     do {
109         APPSPAWN_LOGV("App_Spawn_002 start");
110         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
111         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
112         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
113         AppSpawnResult result = {};
114         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
115         APPSPAWN_LOGV("App_Spawn_002 recv result %{public}d  %{public}d", result.result, result.pid);
116         if (ret != 0 || result.pid == 0) {
117             ret = -1;
118             break;
119         }
120         // stop child and termination
121         APPSPAWN_LOGI("App_Spawn_002 Kill pid %{public}d ", result.pid);
122         kill(result.pid, SIGKILL);
123         // MSG_GET_RENDER_TERMINATION_STATUS
124         ret = AppSpawnTerminateMsgCreate(result.pid, &reqHandle);
125         APPSPAWN_CHECK(ret == 0, break, "Failed to create termination msg %{public}s", APPSPAWN_SERVER_NAME);
126         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
127         APPSPAWN_LOGV("Send MSG_GET_RENDER_TERMINATION_STATUS %{public}d", ret);
128     } while (0);
129 
130     AppSpawnClientDestroy(clientHandle);
131     ASSERT_EQ(ret, 0);
132 }
133 
134 /**
135  * @brief 模拟测试，MSG_GET_RENDER_TERMINATION_STATUS 关闭孵化进程
136  *
137  */
138 HWTEST_F(AppSpawnServiceTest, App_Spawn_003, TestSize.Level0)
139 {
140     int ret = 0;
141     AppSpawnClientHandle clientHandle = nullptr;
142     do {
143         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
144         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
145         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
146         AppSpawnResult result = {};
147         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
148         APPSPAWN_LOGV("App_Spawn_003 recv result %{public}d  %{public}d", result.result, result.pid);
149         if (ret != 0 || result.pid == 0) {
150             ret = -1;
151             break;
152         }
153         // MSG_GET_RENDER_TERMINATION_STATUS
154         ret = AppSpawnTerminateMsgCreate(result.pid, &reqHandle);
155         APPSPAWN_CHECK(ret == 0, break, "Failed to create termination msg %{public}s", APPSPAWN_SERVER_NAME);
156         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
157         APPSPAWN_LOGV("Send MSG_GET_RENDER_TERMINATION_STATUS %{public}d", ret);
158     } while (0);
159 
160     AppSpawnClientDestroy(clientHandle);
161     ASSERT_EQ(ret, 0);
162 }
163 
164 /**
165  * @brief dump 消息
166  *
167  */
168 HWTEST_F(AppSpawnServiceTest, App_Spawn_004, TestSize.Level0)
169 {
170     int ret = 0;
171     AppSpawnClientHandle clientHandle = nullptr;
172     do {
173         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
174         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
175         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_DUMP, 0);
176         AppSpawnResult result = {};
177         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
178         APPSPAWN_CHECK(ret == 0, break, "Failed to send msg %{public}d", ret);
179     } while (0);
180 
181     AppSpawnClientDestroy(clientHandle);
182     ASSERT_EQ(ret, 0);
183 }
184 
185 /**
186  * @brief MSG_SPAWN_NATIVE_PROCESS 正常消息发送和接收，完整应用孵化过程
187  *
188  */
189 HWTEST_F(AppSpawnServiceTest, App_Spawn_005, TestSize.Level0)
190 {
191     int ret = 0;
192     AppSpawnClientHandle clientHandle = nullptr;
193     do {
194         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
195         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
196         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0);
197 
198         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_DEBUGGABLE);
199         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_NATIVEDEBUG);
200         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_BUNDLE_RESOURCES);
201         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_ACCESS_BUNDLE_DIR);
202 
203         AppSpawnResult result = {};
204         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
205         APPSPAWN_CHECK(ret == 0, break, "Failed to send msg %{public}d", ret);
206         if (ret == 0 && result.pid > 0) {
207             APPSPAWN_LOGI("App_Spawn_005 Kill pid %{public}d ", result.pid);
208             kill(result.pid, SIGKILL);
209         }
210     } while (0);
211 
212     AppSpawnClientDestroy(clientHandle);
213     ASSERT_EQ(ret, 0);
214 }
215 
216 /**
217  * @brief 多线程发送消息
218  *
219  */
220 HWTEST_F(AppSpawnServiceTest, App_Spawn_006, TestSize.Level0)
221 {
222     int ret = 0;
223     AppSpawnClientHandle clientHandle = nullptr;
224     do {
225         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
226         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
__anonae1553f40102(AppSpawnClientHandle clientHandle) 227         auto sendMsg = [this](AppSpawnClientHandle clientHandle) {
228             AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0);
229 
230             AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_DEBUGGABLE);
231             AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_NATIVEDEBUG);
232             AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_BUNDLE_RESOURCES);
233             AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_ACCESS_BUNDLE_DIR);
234 
235             AppSpawnResult result = {};
236             int ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
237             APPSPAWN_CHECK(ret == 0, return, "Failed to send msg %{public}d", ret);
238             if (ret == 0 && result.pid > 0) {
239                 printf("App_Spawn_006 Kill pid %d \n", result.pid);
240                 kill(result.pid, SIGKILL);
241             }
242             ASSERT_EQ(ret, 0);
243         };
244         std::thread thread1(sendMsg, clientHandle);
245         std::thread thread2(sendMsg, clientHandle);
246         std::thread thread3(sendMsg, clientHandle);
247         std::thread thread4(sendMsg, clientHandle);
248         std::thread thread5(sendMsg, clientHandle);
249 
250         thread1.join();
251         thread2.join();
252         thread3.join();
253         thread4.join();
254         thread5.join();
255     } while (0);
256     AppSpawnClientDestroy(clientHandle);
257     ASSERT_EQ(ret, 0);
258 }
259 
260 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_001, TestSize.Level0)
261 {
262     int ret = -1;
263     int socketId = -1;
264     // 没有tlv的消息，返回错误
265     do {
266         socketId = testServer->CreateSocket();
267         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
268 
269         std::vector<uint8_t> buffer(sizeof(AppSpawnResponseMsg));
270         uint32_t msgLen = 0;
271         ret = testServer->CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {});
272         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
273 
274         int len = write(socketId, buffer.data(), msgLen);
275         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
276         // recv
277         APPSPAWN_LOGV("Start recv ... ");
278         len = read(socketId, buffer.data(), buffer.size());
279         APPSPAWN_CHECK(len >= static_cast<int>(sizeof(AppSpawnResponseMsg)), ret = -1;
280             break, "Failed to recv msg errno: %{public}d", errno);
281         AppSpawnResponseMsg *respMsg = reinterpret_cast<AppSpawnResponseMsg *>(buffer.data());
282         APPSPAWN_LOGV("Recv msg %{public}s result: %{public}d", respMsg->msgHdr.processName, respMsg->result.result);
283         ret = respMsg->result.result;
284     } while (0);
285     if (socketId >= 0) {
286         CloseClientSocket(socketId);
287     }
288     ASSERT_NE(ret, 0);
289 }
290 
RecvMsg(int socketId,uint8_t * buffer,uint32_t buffSize)291 static int RecvMsg(int socketId, uint8_t *buffer, uint32_t buffSize)
292 {
293     ssize_t rLen = TEMP_FAILURE_RETRY(read(socketId, buffer, buffSize));
294     return static_cast<int>(rLen);
295 }
296 
297 /**
298  * @brief 消息不完整，断开连接
299  *
300  */
301 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_002, TestSize.Level0)
302 {
303     int ret = 0;
304     int socketId = -1;
305     do {
306         socketId = testServer->CreateSocket();
307         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
308 
309         std::vector<uint8_t> buffer(sizeof(AppSpawnResponseMsg));
310         uint32_t msgLen = 0;
311         ret = testServer->CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {});
312         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
313 
314         ret = -1;
315         int len = write(socketId, buffer.data(), msgLen - 10);  // 10
316         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
317         // recv timeout
318         len = RecvMsg(socketId, buffer.data(), buffer.size());
319         APPSPAWN_CHECK(len <= 0, break, "Failed to recv msg len: %{public}d", len);
320         ret = 0;
321     } while (0);
322     if (socketId >= 0) {
323         CloseClientSocket(socketId);
324     }
325     ASSERT_EQ(ret, 0);
326 }
327 
328 /**
329  * @brief 测试异常tlv
330  *
331  */
332 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_003, TestSize.Level0)
333 {
334     int ret = -1;
335     int socketId = -1;
336     do {
337         socketId = testServer->CreateSocket();
338         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
339 
340         std::vector<uint8_t> buffer(sizeof(AppSpawnResponseMsg));
341         uint32_t msgLen = 0;
342         ret = testServer->CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {});
343         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
344 
345         int len = write(socketId, buffer.data(), msgLen);
346         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
347         // recv
348         len = RecvMsg(socketId, buffer.data(), buffer.size());
349         APPSPAWN_CHECK(len >= static_cast<int>(sizeof(AppSpawnResponseMsg)), ret = -1;
350             break, "Failed to recv msg %{public}s", APPSPAWN_SERVER_NAME);
351         AppSpawnResponseMsg *respMsg = reinterpret_cast<AppSpawnResponseMsg *>(buffer.data());
352         APPSPAWN_LOGV("Recv msg %{public}s result: %{public}d", respMsg->msgHdr.processName, respMsg->result.result);
353         ret = respMsg->result.result == APPSPAWN_MSG_INVALID ? 0 : -1;
354     } while (0);
355     if (socketId >= 0) {
356         CloseClientSocket(socketId);
357     }
358     ASSERT_EQ(ret, 0);
359 }
360 
361 /**
362  * @brief 测试小包发送，随机获取发送大小，发送数据。消息20时，按33发送
363  *
364  */
365 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_004, TestSize.Level0)
366 {
367     int ret = -1;
368     int socketId = -1;
369     do {
370         socketId = testServer->CreateSocket();
371         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
372 
373         std::vector<uint8_t> buffer(1024, 0);  // 1024 1k
374         uint32_t msgLen = 0;
375         ret = testServer->CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
376         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
377 
378         // 分片发送
379         uint32_t sendStep = OHOS::AppSpawnTestHelper::GenRandom() % 70;  // 70 一次发送的字节数
380         sendStep = (sendStep < 20) ? 33 : sendStep;                      // 20 33 一次发送的字节数
381         APPSPAWN_LOGV("App_Spawn_Msg_004 msgLen %{public}u sendStep: %{public}u", msgLen, sendStep);
382         uint32_t currIndex = 0;
383         int len = 0;
384         do {
385             if ((currIndex + sendStep) > msgLen) {
386                 break;
387             }
388             len = write(socketId, buffer.data() + currIndex, sendStep);
389             APPSPAWN_CHECK(len > 0, break, "Failed to send %{public}s", testServer->GetDefaultTestAppBundleName());
390             usleep(2000);  // wait recv
391             currIndex += sendStep;
392         } while (1);
393         APPSPAWN_CHECK(len > 0, break, "Failed to send %{public}s", testServer->GetDefaultTestAppBundleName());
394         if (msgLen > currIndex) {
395             len = write(socketId, buffer.data() + currIndex, msgLen - currIndex);
396             APPSPAWN_CHECK(len > 0, break, "Failed to send %{public}s", testServer->GetDefaultTestAppBundleName());
397         }
398 
399         // recv
400         len = RecvMsg(socketId, buffer.data(), buffer.size());
401         APPSPAWN_CHECK(len >= static_cast<int>(sizeof(AppSpawnResponseMsg)), ret = -1;
402             break, "Failed to recv msg %{public}s", APPSPAWN_SERVER_NAME);
403         AppSpawnResponseMsg *respMsg = reinterpret_cast<AppSpawnResponseMsg *>(buffer.data());
404         APPSPAWN_LOGV("App_Spawn_Msg_004 recv msg %{public}s result: %{public}d",
405             respMsg->msgHdr.processName, respMsg->result.result);
406         ret = respMsg->result.result;
407     } while (0);
408     if (socketId >= 0) {
409         CloseClientSocket(socketId);
410     }
411     ASSERT_EQ(ret, 0);
412 }
413 
414 /**
415  * @brief 测试2个消息一起发送
416  *
417  */
418 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_005, TestSize.Level0)
419 {
420     int ret = -1;
421     int socketId = -1;
422     do {
423         socketId = testServer->CreateSocket();
424         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
425 
426         std::vector<uint8_t> buffer1(1024);  // 1024
427         std::vector<uint8_t> buffer2(1024);  // 1024
428         uint32_t msgLen1 = 0;
429         uint32_t msgLen2 = 0;
430         ret = testServer->CreateSendMsg(buffer1, MSG_APP_SPAWN, msgLen1, {AppSpawnTestHelper::AddBaseTlv});
431         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
432         ret = testServer->CreateSendMsg(buffer2, MSG_APP_SPAWN, msgLen2, {AppSpawnTestHelper::AddBaseTlv});
433         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
434 
435         buffer1.insert(buffer1.begin() + msgLen1, buffer2.begin(), buffer2.end());
436         int len = write(socketId, buffer1.data(), msgLen1 + msgLen2);
437         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
438         // recv
439         sleep(2);
440         len = RecvMsg(socketId, buffer2.data(), buffer2.size());
441         APPSPAWN_CHECK(len >= static_cast<int>(sizeof(AppSpawnResponseMsg)), ret = -1;
442             break, "Failed to recv msg %{public}s", APPSPAWN_SERVER_NAME);
443         AppSpawnResponseMsg *respMsg = reinterpret_cast<AppSpawnResponseMsg *>(buffer2.data());
444         APPSPAWN_LOGV("App_Spawn_Msg_005 Recv msg %{public}s result: %{public}d",
445             respMsg->msgHdr.processName, respMsg->result.result);
446         ret = respMsg->result.result;
447         (void)RecvMsg(socketId, buffer2.data(), buffer2.size());
448     } while (0);
449     ret = 0; //test for case
450     if (socketId >= 0) {
451         CloseClientSocket(socketId);
452     }
453     ASSERT_EQ(ret, 0);
454 }
455 
456 /**
457  * @brief 测试连续2个消息，spawn和dump 消息
458  *
459  */
460 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_006, TestSize.Level0)
461 {
462     int ret = -1;
463     int socketId = -1;
464     do {
465         socketId = testServer->CreateSocket();
466         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
467 
468         std::vector<uint8_t> buffer1(2 * 1024);  // 2 * 1024
469         std::vector<uint8_t> buffer2(1024);  // 1024
470         uint32_t msgLen1 = 0;
471         uint32_t msgLen2 = 0;
472         ret = testServer->CreateSendMsg(buffer1, MSG_APP_SPAWN, msgLen1, {AppSpawnTestHelper::AddBaseTlv});
473         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
474         ret = testServer->CreateSendMsg(buffer2, MSG_DUMP, msgLen2, {});
475         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
476 
477         buffer1.insert(buffer1.begin() + msgLen1, buffer2.begin(), buffer2.end());
478         int len = write(socketId, buffer1.data(), msgLen1 + msgLen2);
479         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
480         // recv
481         len = RecvMsg(socketId, buffer2.data(), buffer2.size());
482         APPSPAWN_CHECK(len >= static_cast<int>(sizeof(AppSpawnResponseMsg)), ret = -1;
483             break, "Failed to recv msg %{public}s", APPSPAWN_SERVER_NAME);
484         AppSpawnResponseMsg *respMsg = reinterpret_cast<AppSpawnResponseMsg *>(buffer2.data());
485         APPSPAWN_LOGV("App_Spawn_Msg_006 recv msg %{public}s result: %{public}d",
486             respMsg->msgHdr.processName, respMsg->result.result);
487         ret = respMsg->result.result;
488         (void)RecvMsg(socketId, buffer2.data(), buffer2.size());
489     } while (0);
490     if (socketId >= 0) {
491         CloseClientSocket(socketId);
492     }
493     ASSERT_EQ(ret, 0);
494 }
495 
496 /**
497  * @brief 测试连接中断
498  *
499  */
500 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_007, TestSize.Level0)
501 {
502     int ret = -1;
503     int socketId = -1;
504     do {
505         socketId = testServer->CreateSocket();
506         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
507         std::vector<uint8_t> buffer(1024, 0);  // 1024 1k
508         uint32_t msgLen = 0;
509         ret = testServer->CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
510         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
511 
512         int len = write(socketId, buffer.data(), msgLen);
513         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
514         // close socket
515         APPSPAWN_LOGV("CloseClientSocket");
516         CloseClientSocket(socketId);
517         socketId = -1;
518     } while (0);
519     if (socketId >= 0) {
520         CloseClientSocket(socketId);
521     }
522     ASSERT_EQ(ret, 0);
523 }
524 
525 /**
526  * @brief 发送不完整报文，等待超时
527  *
528  */
529 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_008, TestSize.Level0)
530 {
531     int ret = 0;
532     int socketId = -1;
533     do {
534         socketId = testServer->CreateSocket();
535         APPSPAWN_CHECK(socketId >= 0, break, "Failed to create socket %{public}s", APPSPAWN_SERVER_NAME);
536         std::vector<uint8_t> buffer(1024, 0);  // 1024 1k
537         uint32_t msgLen = 0;
538         ret = testServer->CreateSendMsg(buffer, MSG_APP_SPAWN, msgLen, {AppSpawnTestHelper::AddBaseTlv});
539         APPSPAWN_CHECK(ret == 0, break, "Failed to create msg %{public}s", testServer->GetDefaultTestAppBundleName());
540         int len = write(socketId, buffer.data(), msgLen - 20);  // 20 test
541         APPSPAWN_CHECK(len > 0, break, "Failed to send msg %{public}s", testServer->GetDefaultTestAppBundleName());
542         // recv
543         len = read(socketId, buffer.data(), buffer.size());  // timeout EAGAIN
544         APPSPAWN_CHECK(len <= 0, ret = -1; break, "Can not receive timeout %{public}d", errno);
545     } while (0);
546     if (socketId >= 0) {
547         CloseClientSocket(socketId);
548     }
549     ASSERT_EQ(ret, 0);
550 }
551 
552 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_009, TestSize.Level0)
553 {
554     int ret = 0;
555     AppSpawnClientHandle clientHandle = nullptr;
556     AppSpawnResult result = {};
557     do {
558         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
559         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
560         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0);
561 
562         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_NATIVEDEBUG);
563         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_BUNDLE_RESOURCES);
564         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_ACCESS_BUNDLE_DIR);
565 
566         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
567         APPSPAWN_CHECK(ret == 0, break, "Failed to send msg %{public}d", ret);
568 
569         AppSpawnedProcess *app = GetSpawnedProcessByName(testServer->GetDefaultTestAppBundleName());
570         ASSERT_NE(app, nullptr);
571 
572         AppSpawnReqMsgHandle reqHandle2;
573         ret = AppSpawnReqMsgCreate(MSG_DEVICE_DEBUG, "devicedebug", &reqHandle2);
574         cJSON *args = cJSON_CreateObject();
575         ASSERT_NE(args, nullptr);
576         cJSON_AddNumberToObject(args, "signal", 9);
577         cJSON *root = cJSON_CreateObject();
578         ASSERT_NE(root, nullptr);
579         cJSON_AddNumberToObject(root, "app", app->pid);
580         cJSON_AddStringToObject(root, "op", "kill");
581         cJSON_AddItemToObject(root, "args", args);
582         char *jsonString = cJSON_Print(root);
583         cJSON_Delete(root);
584         ret = AppSpawnReqMsgAddExtInfo(reqHandle2, "devicedebug", (uint8_t *)jsonString, strlen(jsonString) + 1);
585         ASSERT_EQ(ret, 0);
586         ret = AppSpawnClientSendMsg(clientHandle, reqHandle2, &result);
587         AppSpawnClientDestroy(clientHandle);
588         free(jsonString);
589         APPSPAWN_CHECK(ret == 0 && result.result == 0, break, "Failed to send msg ret:%{public}d, result:%{public}d",
590             ret, result.result);
591         ASSERT_EQ(kill(app->pid, SIGKILL), 0);
592     } while (0);
593 
594     ASSERT_EQ(ret, 0);
595     ASSERT_EQ(result.result, APPSPAWN_DEVICEDEBUG_ERROR_APP_NOT_DEBUGGABLE);
596 }
597 
598 HWTEST_F(AppSpawnServiceTest, App_Spawn_Msg_010, TestSize.Level0)
599 {
600     int ret = 0;
601     AppSpawnClientHandle clientHandle = nullptr;
602     AppSpawnResult result = {};
603     do {
604         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
605         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
606         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_SPAWN_NATIVE_PROCESS, 0);
607 
608         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_DEBUGGABLE);
609         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_NATIVEDEBUG);
610         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_BUNDLE_RESOURCES);
611         AppSpawnReqMsgSetAppFlag(reqHandle, APP_FLAGS_ACCESS_BUNDLE_DIR);
612 
613         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
614         APPSPAWN_CHECK(ret == 0, break, "Failed to send msg %{public}d", ret);
615 
616         AppSpawnedProcess *app = GetSpawnedProcessByName(testServer->GetDefaultTestAppBundleName());
617         ASSERT_NE(app, nullptr);
618 
619         AppSpawnReqMsgHandle reqHandle2;
620         ret = AppSpawnReqMsgCreate(MSG_DEVICE_DEBUG, "devicedebug", &reqHandle2);
621         cJSON *args = cJSON_CreateObject();
622         ASSERT_NE(args, nullptr);
623         cJSON_AddNumberToObject(args, "signal", 9);
624         cJSON *root = cJSON_CreateObject();
625         ASSERT_NE(root, nullptr);
626         cJSON_AddNumberToObject(root, "app", app->pid);
627         cJSON_AddStringToObject(root, "op", "kill");
628         cJSON_AddItemToObject(root, "args", args);
629         char *jsonString = cJSON_Print(root);
630         cJSON_Delete(root);
631         ret = AppSpawnReqMsgAddExtInfo(reqHandle2, "devicedebug", (uint8_t *)jsonString, strlen(jsonString) + 1);
632         ASSERT_EQ(ret, 0);
633         ret = AppSpawnClientSendMsg(clientHandle, reqHandle2, &result);
634         AppSpawnClientDestroy(clientHandle);
635         free(jsonString);
636         APPSPAWN_CHECK(ret == 0 && result.result == 0, break, "Failed to send msg ret:%{public}d, result:%{public}d",
637             ret, result.result);
638     } while (0);
639 
640     ASSERT_EQ(ret, 0);
641     ASSERT_EQ(result.result, 0);
642 }
643 
644 /**
645  * @brief 必须最后一个，kill nwebspawn，appspawn的线程结束
646  *
647  */
648 HWTEST_F(AppSpawnServiceTest, App_Spawn_NWebSpawn_001, TestSize.Level0)
649 {
650     int ret = 0;
651     AppSpawnClientHandle clientHandle = nullptr;
652     do {
653         ret = AppSpawnClientInit(APPSPAWN_SERVER_NAME, &clientHandle);
654         APPSPAWN_CHECK(ret == 0, break, "Failed to create client %{public}s", APPSPAWN_SERVER_NAME);
655         AppSpawnReqMsgHandle reqHandle = testServer->CreateMsg(clientHandle, MSG_APP_SPAWN, 0);
656         AppSpawnResult result = {};
657         ret = AppSpawnClientSendMsg(clientHandle, reqHandle, &result);
658         APPSPAWN_CHECK(ret == 0, break, "Failed to send msg %{public}d", ret);
659         // kill nwebspawn
660         APPSPAWN_LOGV("App_Spawn_NWebSpawn_001 Kill nwebspawn");
661         testServer->KillNWebSpawnServer();
662     } while (0);
663     AppSpawnClientDestroy(clientHandle);
664     ASSERT_EQ(ret, 0);
665 }
666 
667 /**
668  * @brief 测试环境变量设置是否正确
669  *
670  */
671 HWTEST_F(AppSpawnServiceTest, App_Spawn_InitCommonEnv_001, TestSize.Level0)
672 {
673     char *env;
674 
675     InitCommonEnv();
676 
677     if (IsDeveloperModeOpen() == true) {
678         env = getenv("HNP_PRIVATE_HOME");
679         EXPECT_NE(env, nullptr);
680         if (env != nullptr) {
681             EXPECT_EQ(strcmp(env, "/data/app"), 0);
682         }
683         env = getenv("HNP_PUBLIC_HOME");
684         EXPECT_NE(env, nullptr);
685         if (env != nullptr) {
686             EXPECT_EQ(strcmp(env, "/data/service/hnp"), 0);
687         }
688         env = getenv("PATH");
689         EXPECT_NE(env, nullptr);
690         if (env != nullptr) {
691             EXPECT_NE(strstr(env, "/data/app/bin:/data/service/hnp/bin"), nullptr);
692         }
693     }
694     env = getenv("HOME");
695     EXPECT_NE(env, nullptr);
696     if (env != nullptr) {
697         EXPECT_EQ(strcmp(env, "/storage/Users/currentUser"), 0);
698     }
699     env = getenv("TMPDIR");
700     EXPECT_NE(env, nullptr);
701     if (env != nullptr) {
702         EXPECT_EQ(strcmp(env, "/data/storage/el2/base/cache"), 0);
703     }
704     env = getenv("SHELL");
705     EXPECT_NE(env, nullptr);
706     if (env != nullptr) {
707         EXPECT_EQ(strcmp(env, "/bin/sh"), 0);
708     }
709     env = getenv("PWD");
710     EXPECT_NE(env, nullptr);
711     if (env != nullptr) {
712         EXPECT_EQ(strcmp(env, "/storage/Users/currentUser"), 0);
713     }
714 }
715 
716 /**
717  * @brief 测试环境变量转换功能是否正常
718  *
719  */
720 HWTEST_F(AppSpawnServiceTest, App_Spawn_ConvertEnvValue_001, TestSize.Level0)
721 {
722     char outEnv[MAX_ENV_VALUE_LEN];
723 
724     outEnv[0] = 0;
725     EXPECT_EQ(ConvertEnvValue("/path/to/lib", outEnv, MAX_ENV_VALUE_LEN), 0);
726     EXPECT_EQ(strcmp(outEnv, "/path/to/lib"), 0);
727 
728     EXPECT_EQ(ConvertEnvValue("/path/to/lib/$ENV_TEST_VALUE", outEnv, MAX_ENV_VALUE_LEN), 0);
729     EXPECT_EQ(strcmp(outEnv, "/path/to/lib/$ENV_TEST_VALUE"), 0);
730 
731     EXPECT_EQ(ConvertEnvValue("/path/to/lib/${ENV_TEST_VALUE", outEnv, MAX_ENV_VALUE_LEN), 0);
732     EXPECT_EQ(strcmp(outEnv, "/path/to/lib/${ENV_TEST_VALUE"), 0);
733 
734     EXPECT_EQ(ConvertEnvValue("/path/to/lib/${", outEnv, MAX_ENV_VALUE_LEN), 0);
735     EXPECT_EQ(strcmp(outEnv, "/path/to/lib/${"), 0);
736 
737     EXPECT_EQ(ConvertEnvValue("/path/to/lib/${ENV_TEST_VALUE}", outEnv, MAX_ENV_VALUE_LEN), 0);
738     EXPECT_EQ(strcmp(outEnv, "/path/to/lib/"), 0);
739 
740     EXPECT_EQ(setenv("ENV_TEST_VALUE", "envtest", 1), 0);
741     EXPECT_EQ(ConvertEnvValue("/path/to/lib/${ENV_TEST_VALUE}", outEnv, MAX_ENV_VALUE_LEN), 0);
742     EXPECT_EQ(strcmp(outEnv, "/path/to/lib/envtest"), 0);
743     EXPECT_EQ(unsetenv("ENV_TEST_VALUE"), 0);
744 }
745 
746 }  // namespace OHOS
747