1 /*
2 * Copyright (c) 2022 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 <cinttypes>
17 #include <sys/mount.h>
18 #include "fs_manager/fs_manager.h"
19 #include "init_log.h"
20 #include "init_param.h"
21 #include "param_stub.h"
22 #include "securec.h"
23 #include "parameter.h"
24 #include "systemcapability.h"
25 #include "service_control.h"
26 #include "control_fd.h"
27 #include "loop_event.h"
28 #include "fd_holder.h"
29 #include "fd_holder_internal.h"
30
31 using namespace testing::ext;
32 using namespace std;
33
34 namespace init_ut {
35
36 extern "C" {
37 void CmdDisConnectComplete(const TaskHandle client);
38 void CmdOnSendMessageComplete(const TaskHandle task, const BufferHandle handle);
39 void CmdOnClose(const TaskHandle task);
40 void CmdOnConnectComplete(const TaskHandle client);
41 void CmdOnRecvMessage(const TaskHandle task, const uint8_t *buffer, uint32_t buffLen);
42 void ProcessPtyRead(const WatcherHandle taskHandle, int fd, uint32_t *events, const void *context);
43 void ProcessPtyWrite(const WatcherHandle taskHandle, int fd, uint32_t *events, const void *context);
44 int CmdOnIncommingConnect(const LoopHandle loop, const TaskHandle server);
45 CmdAgent *CmdAgentCreate(const char *server);
46 void CmdClientOnRecvMessage(const TaskHandle task, const uint8_t *buffer, uint32_t buffLen);
47 int SendCmdMessage(const CmdAgent *agent, uint16_t type, const char *cmd, const char *ptyName);
48 int SendMessage(LoopHandle loop, TaskHandle task, const char *message);
49 int *GetFdsFromMsg(size_t *outFdCount, pid_t *requestPid, struct msghdr msghdr);
50 int BuildSendData(char *buffer, size_t size, const char *serviceName, bool hold, bool poll);
51 int CheckSocketPermission(const TaskHandle task);
52 }
53
54 class InnerkitsUnitTest : public testing::Test {
55 public:
SetUpTestCase(void)56 static void SetUpTestCase(void) {};
TearDownTestCase(void)57 static void TearDownTestCase(void) {};
SetUp()58 void SetUp() {};
TearDown()59 void TearDown() {};
60 };
61
CallbackSendMsgProcessTest(const CmdAgent * agent,uint16_t type,const char * cmd,const char * ptyName)62 static int CallbackSendMsgProcessTest(const CmdAgent *agent, uint16_t type, const char *cmd, const char *ptyName)
63 {
64 return 0;
65 }
66
TestCmdServiceProcessDelClient(pid_t pid)67 static int TestCmdServiceProcessDelClient(pid_t pid)
68 {
69 CmdServiceProcessDelClient(pid);
70 return 0;
71 }
72
73 /**
74 * @tc.name: ReadFstabFromFile_unitest
75 * @tc.desc: read fstab from test file.
76 * @tc.type: FUNC
77 * @tc.require:
78 * @tc.author:
79 */
80 HWTEST_F(InnerkitsUnitTest, Init_InnerkitsTest_ReadFstabFromFile001, TestSize.Level1)
81 {
82 Fstab *fstab = nullptr;
83 const std::string fstabFile1 = "/data/fstab.updater1";
84 fstab = ReadFstabFromFile(fstabFile1.c_str(), false);
85 EXPECT_EQ(fstab, nullptr);
86 const std::string fstabFile2 = STARTUP_INIT_UT_PATH"/mount_unitest/ReadFstabFromFile1.fstable";
87 fstab = ReadFstabFromFile(fstabFile2.c_str(), false);
88 EXPECT_NE(fstab, nullptr);
89 ParseFstabPerLine(const_cast<char *>("test"), fstab, true, nullptr);
90 ReleaseFstab(fstab);
91 }
92
93 /**
94 * @tc.name: FindFstabItemForPath_unitest
95 * @tc.desc: read fstab from test file, then find item according to path.
96 * @tc.type: FUNC
97 * @tc.require:
98 * @tc.author:
99 */
100 HWTEST_F(InnerkitsUnitTest, Init_InnerkitsTest_FindFstabItemForPath001, TestSize.Level1)
101 {
102 const std::string fstabFile1 = STARTUP_INIT_UT_PATH"/mount_unitest/ReadFstabFromFile1.fstable";
103 Fstab *fstab = nullptr;
104 fstab = ReadFstabFromFile(fstabFile1.c_str(), false);
105 ASSERT_NE(fstab, nullptr);
106 FstabItem* item = nullptr;
107 const std::string path1 = "";
108 item = FindFstabItemForPath(*fstab, path1.c_str());
109 if (item == nullptr) {
110 SUCCEED();
111 }
112 const std::string path2 = "/data";
113 item = FindFstabItemForPath(*fstab, path2.c_str());
114 if (item != nullptr) {
115 SUCCEED();
116 }
117 const std::string path3 = "/data2";
118 item = FindFstabItemForPath(*fstab, path3.c_str());
119 if (item == nullptr) {
120 SUCCEED();
121 }
122 const std::string path4 = "/data2/test";
123 item = FindFstabItemForPath(*fstab, path4.c_str());
124 if (item != nullptr) {
125 SUCCEED();
126 }
127 ReleaseFstab(fstab);
128 fstab = nullptr;
129 }
130
131 /**
132 * @tc.name: FindFstabItemForMountPoint_unitest
133 * @tc.desc: read fstab from test file, then find item that matches with the mount point.
134 * @tc.type: FUNC
135 * @tc.require:
136 * @tc.author:
137 */
138 HWTEST_F(InnerkitsUnitTest, Init_InnerkitsTest_FindFstabItemForMountPoint001, TestSize.Level1)
139 {
140 const std::string fstabFile1 = STARTUP_INIT_UT_PATH"/mount_unitest/ReadFstabFromFile1.fstable";
141 Fstab *fstab = nullptr;
142 fstab = ReadFstabFromFile(fstabFile1.c_str(), false);
143 ASSERT_NE(fstab, nullptr);
144 FstabItem* item = nullptr;
145 const std::string mp1 = "/data";
146 const std::string mp2 = "/data2";
147 item = FindFstabItemForMountPoint(*fstab, mp2.c_str());
148 if (item == nullptr) {
149 SUCCEED();
150 }
151 const std::string mp3 = "/data";
152 item = FindFstabItemForMountPoint(*fstab, mp3.c_str());
153 if (item != nullptr) {
154 SUCCEED();
155 }
156 ReleaseFstab(fstab);
157 fstab = nullptr;
158 }
159
160 /**
161 * @tc.name: GetMountFlags_unitest
162 * @tc.desc: read fstab from test file, then find the item and get mount flags.
163 * @tc.type: FUNC
164 * @tc.require:
165 * @tc.author:
166 */
167 HWTEST_F(InnerkitsUnitTest, Init_InnerkitsTest_GetMountFlags001, TestSize.Level1)
168 {
169 const std::string fstabFile1 = STARTUP_INIT_UT_PATH"/mount_unitest/ReadFstabFromFile1.fstable";
170 Fstab *fstab = nullptr;
171 fstab = ReadFstabFromFile(fstabFile1.c_str(), true);
172 ASSERT_NE(fstab, nullptr);
173 struct FstabItem* item = nullptr;
174 const std::string mp = "/hos";
175 item = FindFstabItemForMountPoint(*fstab, mp.c_str());
176 if (item == nullptr) {
177 SUCCEED();
178 }
179 const int bufferSize = 512;
180 char fsSpecificOptions[bufferSize] = {0};
181 unsigned long flags = GetMountFlags(item->mountOptions, fsSpecificOptions, bufferSize, item->mountPoint);
182 EXPECT_EQ(flags, static_cast<unsigned long>(MS_NOSUID | MS_NODEV | MS_NOATIME));
183 ReleaseFstab(fstab);
184 fstab = nullptr;
185 }
186
187 /**
188 * @tc.name: GetSlotInfo_unittest
189 * @tc.desc: get the number of slots and get current slot.
190 * @tc.type: FUNC
191 * @tc.require:issueI5NTX2
192 * @tc.author:
193 */
194 HWTEST_F(InnerkitsUnitTest, Init_InnerkitsTest_GetSlotInfo001, TestSize.Level1)
195 {
196 EXPECT_NE(GetBootSlots(), -1);
197 EXPECT_NE(GetCurrentSlot(), -1);
198 }
199
200 /**
201 * @tc.name: LoadFstabFromCommandLine_unittest
202 * @tc.desc: get fstab from command line.
203 * @tc.type: FUNC
204 * @tc.require:issueI5NTX2
205 * @tc.author:
206 */
207 HWTEST_F(InnerkitsUnitTest, Init_InnerkitsTest_LoadFstabFromCommandLine001, TestSize.Level1)
208 {
209 EXPECT_NE(LoadFstabFromCommandLine(), (Fstab *)nullptr);
210 }
211
212 /**
213 * @tc.name: GetBlockDevicePath_unittest
214 * @tc.desc: get block device path according to valid or invalid partition.
215 * @tc.type: FUNC
216 * @tc.require:issueI5NTX2
217 * @tc.author:
218 */
219 HWTEST_F(InnerkitsUnitTest, Init_InnerkitsTest_GetBlockDevicePath001, TestSize.Level1)
220 {
221 char devicePath[MAX_BUFFER_LEN] = {0};
222 EXPECT_EQ(GetBlockDevicePath("/vendor", devicePath, MAX_BUFFER_LEN), 0);
223 EXPECT_EQ(GetBlockDevicePath("/misc", devicePath, MAX_BUFFER_LEN), 0);
224 EXPECT_EQ(GetBlockDevicePath("/invalid", devicePath, MAX_BUFFER_LEN), -1);
225 unlink(BOOT_CMD_LINE);
226 EXPECT_EQ(GetBlockDevicePath("/invalid", devicePath, MAX_BUFFER_LEN), -1);
227 GetCurrentSlot();
228 // restore cmdline
229 PrepareCmdLineData();
230 }
231
232 /**
233 * @tc.name: DoFormat_unittest
234 * @tc.desc: format file system, includes ext4 and f2fs type.
235 * @tc.type: FUNC
236 * @tc.require:
237 * @tc.author:
238 */
239 HWTEST_F(InnerkitsUnitTest, Init_InnerkitsTest_DoFormat001, TestSize.Level1)
240 {
241 EXPECT_NE(DoFormat("/testpath", "ext4"), -1);
242 EXPECT_NE(DoFormat("/testpath", "f2fs"), -1);
243 EXPECT_EQ(DoFormat("/testpath", "notFs"), -1);
244 EXPECT_EQ(DoFormat(nullptr, nullptr), -1);
245 }
246
247 /**
248 * @tc.name: MountAllWithFstabFile_unittest
249 * @tc.desc: mount partitions according to fstab that read from file.
250 * @tc.type: FUNC
251 * @tc.require:issueI5NTX2
252 * @tc.author:
253 */
254 HWTEST_F(InnerkitsUnitTest, Init_InnerkitsTest_MountAllWithFstabFile001, TestSize.Level1)
255 {
256 EXPECT_NE(MountAllWithFstabFile(STARTUP_INIT_UT_PATH"/etc/fstab.required", 0), 1);
257 EXPECT_NE(UmountAllWithFstabFile(STARTUP_INIT_UT_PATH"/etc/fstab.required"), 1);
258 EXPECT_EQ(MountAllWithFstabFile("/testErrorFile", 0), -1);
259 EXPECT_EQ(MountAllWithFstabFile(nullptr, 0), -1);
260 EXPECT_EQ(GetMountStatusForMountPoint(nullptr), -1);
261 FstabItem fstabItem = {};
262 fstabItem.fsType = strdup("notSupport");
263 fstabItem.mountPoint = strdup("");
264 EXPECT_EQ(MountOneItem(nullptr), -1);
265 EXPECT_EQ(MountOneItem(&fstabItem), 0);
266 if (fstabItem.fsType != nullptr) {
267 free(fstabItem.fsType);
268 fstabItem.fsType = nullptr;
269 }
270 if (fstabItem.mountPoint != nullptr) {
271 free(fstabItem.mountPoint);
272 fstabItem.mountPoint = nullptr;
273 }
274 }
275
276 #define SYSCAP_MAX_SIZE 100
277
278 // TestSysCap
279 HWTEST_F(InnerkitsUnitTest, Init_InnerkitsTest_TestSysCap001, TestSize.Level1)
280 {
281 bool ret = HasSystemCapability("test.cap");
282 EXPECT_EQ(ret, false);
283 ret = HasSystemCapability(nullptr);
284 EXPECT_EQ(ret, false);
285 ret = HasSystemCapability("ArkUI.ArkUI.Napi");
286 EXPECT_EQ(ret, true);
287 ret = HasSystemCapability("SystemCapability.ArkUI.ArkUI.Napi");
288 EXPECT_EQ(ret, true);
289 char *wrongName = reinterpret_cast<char *>(malloc(SYSCAP_MAX_SIZE));
290 ASSERT_NE(wrongName, nullptr);
291 EXPECT_EQ(memset_s(wrongName, SYSCAP_MAX_SIZE, 1, SYSCAP_MAX_SIZE), 0);
292 HasSystemCapability(wrongName);
293 free(wrongName);
294 }
295
296 #define API_VERSION_MAX 999
297 // TestIsApiVersionGreaterOrEqual
298 HWTEST_F(InnerkitsUnitTest, Init_InnerkitsTest_TestIsApiVersionGreaterOrEqual001, TestSize.Level1)
299 {
300 // 验证非法版本
301 bool ret = CheckApiVersionGreaterOrEqual(0, 0, 0);
302 EXPECT_EQ(ret, false);
303 ret = CheckApiVersionGreaterOrEqual(API_VERSION_MAX + 1, 0, 0);
304 EXPECT_EQ(ret, false);
305 ret = CheckApiVersionGreaterOrEqual(1, -1, 0);
306 EXPECT_EQ(ret, false);
307 ret = CheckApiVersionGreaterOrEqual(1, API_VERSION_MAX + 1, 0);
308 EXPECT_EQ(ret, false);
309 ret = CheckApiVersionGreaterOrEqual(1, 0, -1);
310 EXPECT_EQ(ret, false);
311 ret = CheckApiVersionGreaterOrEqual(1, 0, API_VERSION_MAX + 1);
312 EXPECT_EQ(ret, false);
313
314 // 获取设备api版本号
315 int majorApiVersion = GetSdkApiVersion();
316 int minorApiVersion = GetSdkMinorApiVersion();
317 int patchApiVersion = GetSdkPatchApiVersion();
318 printf("IsApiVersionGreaterOrEqual, major:%d, minor:%d, patch:%d\n", majorApiVersion,
319 minorApiVersion, patchApiVersion);
320 // 设备版本号异常校验
321 if (majorApiVersion < 1 || majorApiVersion > API_VERSION_MAX ||
322 minorApiVersion < -1 || minorApiVersion > API_VERSION_MAX ||
323 patchApiVersion < -1 || minorApiVersion > API_VERSION_MAX) {
324 EXPECT_EQ(ret, true);
325 } else {
326 // 验证传参等于系统版本时返回true
327 ret = CheckApiVersionGreaterOrEqual(majorApiVersion, minorApiVersion, patchApiVersion);
328 EXPECT_EQ(ret, true);
329 majorApiVersion += 1;
330 ret = CheckApiVersionGreaterOrEqual(majorApiVersion, minorApiVersion, patchApiVersion);
331 EXPECT_EQ(ret, false);
332 majorApiVersion -= 2;
333 ret = CheckApiVersionGreaterOrEqual(majorApiVersion, minorApiVersion, patchApiVersion);
334 if (majorApiVersion > API_VERSION_MAX || majorApiVersion < 1) {
335 EXPECT_EQ(ret, false);
336 } else {
337 EXPECT_EQ(ret, true);
338 }
339 majorApiVersion += 1;
340 minorApiVersion += 1;
341 ret = CheckApiVersionGreaterOrEqual(majorApiVersion, minorApiVersion, patchApiVersion);
342 EXPECT_EQ(ret, false);
343 minorApiVersion -= 2;
344 ret = CheckApiVersionGreaterOrEqual(majorApiVersion, minorApiVersion, patchApiVersion);
345 if (minorApiVersion > API_VERSION_MAX || minorApiVersion < 0) {
346 EXPECT_EQ(ret, false);
347 } else {
348 EXPECT_EQ(ret, true);
349 }
350 minorApiVersion += 1;
351 patchApiVersion += 1;
352 ret = CheckApiVersionGreaterOrEqual(majorApiVersion, minorApiVersion, patchApiVersion);
353 EXPECT_EQ(ret, false);
354 patchApiVersion -= 2;
355 ret = CheckApiVersionGreaterOrEqual(majorApiVersion, minorApiVersion, patchApiVersion);
356 if (patchApiVersion > API_VERSION_MAX || patchApiVersion < 0) {
357 EXPECT_EQ(ret, false);
358 } else {
359 EXPECT_EQ(ret, true);
360 }
361 }
362 }
363
364 // TestControlService
365 HWTEST_F(InnerkitsUnitTest, Init_InnerkitsTest_ControlService001, TestSize.Level1)
366 {
367 TestSetParamCheckResult("startup.service.ctl.", 0777, 0);
368 ServiceControl("deviceinfoservice", START);
369 SystemWriteParam("startup.service.ctl.deviceinfoservice", "2");
370 ServiceControl("deviceinfoservice", RESTART);
371 ServiceControl("deviceinfoservice", STOP);
372 SystemWriteParam("startup.service.ctl.deviceinfoservice", "0");
373 ServiceControl("param_watcher", RESTART);
374 EXPECT_EQ(ServiceControl(nullptr, RESTART), -1);
375 const char *argv[] = {"testArg"};
376 ServiceControlWithExtra("deviceinfoservice", RESTART, argv, 1);
377 ServiceControlWithExtra(nullptr, RESTART, argv, 1);
378 ServiceControlWithExtra(nullptr, SERVICE_ACTION_MAX, argv, 1); // 3 is action
379 ServiceControlWithExtra("notservie", RESTART, argv, 1);
380 ServiceControlWithExtra("deviceinfoservice", SERVICE_ACTION_MAX, argv, 1); // 3 is action
381 ServiceSetReady("deviceinfoservice");
382 ServiceSetReady(nullptr);
383 ServiceWaitForStatus("deviceinfoservice", SERVICE_READY, 1);
384 ServiceWaitForStatus("deviceinfoservice", SERVICE_READY, -1);
385 ServiceWaitForStatus(nullptr, SERVICE_READY, 1);
386 StartServiceByTimer("deviceinfoservice", 1);
387 StartServiceByTimer("deviceinfoservice", 0);
388 StartServiceByTimer(nullptr, 0);
389 StopServiceTimer("deviceinfoservice");
390 ServiceControlWithExtra("deviceinfoservice", TERM, argv, 1);
391 }
392
TestIncommingConnect(const LoopHandle loop,const TaskHandle server)393 static int TestIncommingConnect(const LoopHandle loop, const TaskHandle server)
394 {
395 UNUSED(loop);
396 UNUSED(server);
397 return 0;
398 }
399
400 // TestControlFd
401 HWTEST_F(InnerkitsUnitTest, Init_InnerkitsTest_ControlFd001, TestSize.Level1)
402 {
403 CmdClientInit("/data/testSock1", ACTION_DUMP, "cmd", nullptr);
404 CmdClientInit("/data/testSock1", ACTION_DUMP, "cmd", CallbackSendMsgProcessTest);
405 CmdClientInit(INIT_CONTROL_FD_SOCKET_PATH, ACTION_DUMP, nullptr, nullptr);
406 CmdClientInit(nullptr, ACTION_DUMP, "cmd", nullptr);
407
408 CmdDisConnectComplete(nullptr);
409 CmdOnSendMessageComplete(nullptr, nullptr);
410 CmdOnConnectComplete(nullptr);
411 CmdClientOnRecvMessage(nullptr, nullptr, 0);
412 CmdAgentCreate(nullptr);
413 CmdAgent *agent = CmdAgentCreate(INIT_CONTROL_FD_SOCKET_PATH);
414 EXPECT_NE(agent, nullptr);
415 SendCmdMessage(agent, ACTION_DUMP, "cmd", "test");
416 SendCmdMessage(agent, ACTION_DUMP, "cmd", nullptr);
417 SendMessage(nullptr, nullptr, nullptr);
418 uint32_t events = 0;
419 InitPtyInterface(agent, 0, "cmd", nullptr);
420 InitPtyInterface(agent, 0, "cmd", CallbackSendMsgProcessTest);
421 InitPtyInterface(agent, 0, nullptr, nullptr);
422 InitPtyInterface(nullptr, 0, nullptr, nullptr);
423 mode_t mode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
424 CheckAndCreatFile("/data/init_ut/testInput", mode);
425 int fd = open("/data/init_ut/testInput", O_RDWR);
426 perror("write failed");
427 EXPECT_GT(fd, 0);
428 EXPECT_GT(write(fd, "test", strlen("test")), 0);
429 perror("write failed");
430 lseek(fd, 0, SEEK_SET);
431 ProcessPtyRead(nullptr, fd, &events, (void *)agent);
432 ProcessPtyRead(nullptr, fd, &events, (void *)agent);
433 ProcessPtyRead(nullptr, STDERR_FILENO, &events, nullptr);
434 lseek(fd, 0, SEEK_SET);
435 ProcessPtyWrite(nullptr, fd, &events, (void *)agent);
436 ProcessPtyWrite(nullptr, fd, &events, (void *)agent);
437 ProcessPtyWrite(nullptr, STDERR_FILENO, &events, nullptr);
438 close(fd);
439
440 if (agent) {
441 CmdOnClose(agent->task);
442 }
443 }
444
445 HWTEST_F(InnerkitsUnitTest, Init_InnerkitsTest_ControlFdServer001, TestSize.Level1)
446 {
447 CmdServiceInit(nullptr, nullptr, nullptr);
__anon3a1450050102(uint16_t type, const char *serviceCmd, const void *context) 448 CmdServiceInit("/data/testSock1", [](uint16_t type, const char *serviceCmd, const void *context) {
449 UNUSED(type);
450 UNUSED(serviceCmd);
451 UNUSED(context);
452 }, LE_GetDefaultLoop());
453
454 TaskHandle testServer = nullptr;
455 LE_StreamServerInfo info = {};
456 info.baseInfo.flags = TASK_STREAM | TASK_SERVER | TASK_PIPE | TASK_TEST;
457 info.server = (char *)"/data/testSock1";
458 info.socketId = -1;
459 info.baseInfo.close = nullptr;
460 info.disConnectComplete = nullptr;
461 info.incommingConnect = TestIncommingConnect;
462 info.sendMessageComplete = nullptr;
463 info.recvMessage = nullptr;
464 (void)LE_CreateStreamServer(LE_GetDefaultLoop(), &testServer, &info);
465 CmdOnIncommingConnect(LE_GetDefaultLoop(), testServer);
466
467 CmdOnRecvMessage(testServer, nullptr, 0);
468 CmdMessage *cmdMsg = (CmdMessage *)malloc(sizeof(CmdMessage) + strlen("test"));
469 cmdMsg->type = ACTION_DUMP;
470 cmdMsg->ptyName[0] = '\0';;
471 CmdOnRecvMessage(testServer, (uint8_t *)(&cmdMsg), 0);
472 cmdMsg->type = ACTION_DUMP;
473 cmdMsg->cmd[0] = 'a';
474 cmdMsg->ptyName[0] = 'a';
475 CmdOnRecvMessage(testServer, (uint8_t *)(&cmdMsg), 0);
476 int ret = TestCmdServiceProcessDelClient(0);
477 EXPECT_EQ(ret, 0);
478 ret = TestCmdServiceProcessDelClient(0);
479 EXPECT_EQ(ret, 0);
480 free(cmdMsg);
481 }
482
483 HWTEST_F(InnerkitsUnitTest, Init_InnerkitsTest_HoldFd001, TestSize.Level1)
484 {
485 int ret = CheckSocketPermission(nullptr);
486 EXPECT_EQ(ret, -1);
487 CmdServiceProcessDestroyClient();
488 }
489
490 HWTEST_F(InnerkitsUnitTest, Init_InnerkitsTest_HoldFd002, TestSize.Level1)
491 {
492 int fds1[] = {1, 0};
493 ServiceSaveFd("testServiceName", fds1, ARRAY_LENGTH(fds1));
494 ServiceSaveFd(nullptr, fds1, ARRAY_LENGTH(fds1));
495 ServiceSaveFdWithPoll("testServiceName", fds1, 0);
496 ServiceSaveFdWithPoll(nullptr, fds1, 0);
497 ServiceSaveFdWithPoll("testServiceName", fds1, ARRAY_LENGTH(fds1));
498 EXPECT_EQ(setenv("OHOS_FD_HOLD_testServiceName", "1 0", 0), 0);
499
500 size_t fdCount = 0;
501 int *fds = nullptr;
502 ServiceGetFd("testService", nullptr);
503 ServiceGetFd("testService", &fdCount);
504 char *wrongName = (char *)malloc(MAX_FD_HOLDER_BUFFER + 1);
505 ASSERT_NE(wrongName, nullptr);
506 EXPECT_EQ(memset_s(wrongName, MAX_FD_HOLDER_BUFFER + 1, 1, MAX_FD_HOLDER_BUFFER + 1), 0);
507 ServiceGetFd(wrongName, &fdCount);
508 BuildSendData(wrongName, 1, "testService", 0, 1);
509 BuildSendData(wrongName, 1, "testService", 0, 0);
510 BuildSendData(nullptr, 1, "testService", 0, 0);
511 free(wrongName);
512
513 fds = ServiceGetFd("testServiceName", &fdCount);
514 EXPECT_NE(fds, nullptr);
515 struct msghdr msghdr = {};
516 BuildControlMessage(nullptr, nullptr, 1, 0);
517 BuildControlMessage(&msghdr, nullptr, 1, 0);
518 if (msghdr.msg_control != nullptr) {
519 free(msghdr.msg_control);
520 msghdr.msg_control = nullptr;
521 }
522 BuildControlMessage(&msghdr, fds, -1, 0);
523 if (msghdr.msg_control != nullptr) {
524 free(msghdr.msg_control);
525 msghdr.msg_control = nullptr;
526 }
527 BuildControlMessage(&msghdr, fds, -1, 1);
528 if (msghdr.msg_control != nullptr) {
529 free(msghdr.msg_control);
530 msghdr.msg_control = nullptr;
531 }
532 if (fds != nullptr)
533 {
534 free(fds);
535 fds = nullptr;
536 }
537 }
538
539 HWTEST_F(InnerkitsUnitTest, Init_InnerkitsTest_HoldFd003, TestSize.Level1)
540 {
541 size_t fdCount = 0;
542 int *fds = nullptr;
543 char buffer[MAX_FD_HOLDER_BUFFER + 1] = {};
544 pid_t requestPid = -1;
545 struct msghdr msghdr = {};
546 GetFdsFromMsg(&fdCount, &requestPid, msghdr);
547 msghdr.msg_flags = MSG_TRUNC;
548 int *ret = nullptr;
549 ret = GetFdsFromMsg(&fdCount, &requestPid, msghdr);
550 EXPECT_EQ(ret, nullptr);
551 struct iovec iovec = {
552 .iov_base = buffer,
553 .iov_len = MAX_FD_HOLDER_BUFFER,
554 };
555 ReceiveFds(0, iovec, &fdCount, false, &requestPid);
556 fds = ReceiveFds(0, iovec, &fdCount, true, &requestPid);
557 if (fds != nullptr)
558 {
559 free(fds);
560 fds = nullptr;
561 }
562 if (msghdr.msg_control != nullptr) {
563 free(msghdr.msg_control);
564 }
565 }
566
567 } // namespace init_ut
568