1 /*
2  * Copyright (c) 2023 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 "dlp_fuse_test.h"
17 
18 #include <cstring>
19 #include <dirent.h>
20 #include <fcntl.h>
21 #include <openssl/rand.h>
22 #include <securec.h>
23 #include <sys/mount.h>
24 #include <sys/stat.h>
25 #include <sys/types.h>
26 #include <thread>
27 #include "accesstoken_kit.h"
28 #define private public
29 #include "dlp_file.h"
30 #undef private
31 #include "dlp_file_manager.h"
32 #define private public
33 #include "dlp_fuse_fd.h"
34 #include "dlp_link_file.h"
35 #include "dlp_link_manager.h"
36 #undef private
37 #include "dlp_permission.h"
38 #include "dlp_permission_log.h"
39 #include "fuse_daemon.h"
40 #include "token_setproc.h"
41 
42 namespace OHOS {
43 namespace Security {
44 namespace DlpPermission {
45 using namespace testing::ext;
46 using namespace OHOS::Security::AccessToken;
47 
48 namespace {
49 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_DLP_PERMISSION, "DlpFuseTest"};
50 // using for clean all link file
51 static const uint32_t LINK_FD_ARRY_SIZE = 4;
52 static int32_t g_linkFdArry[LINK_FD_ARRY_SIZE] = {-1};
53 static const std::string MOUNT_POINT_DIR = "/data/fuse/";
54 static const std::string DLP_TEST_DIR = "/data/dlpTest/";
55 static const std::string FUSE_DEV = "/dev/fuse";
56 static const std::string FUSE_TYPE = "fuse";
57 static const int32_t KERNEL_OPT_MAXLEN = 128;
58 static const std::string TEST_LINK_FILE_NAME = "fuse_test.txt.link";
59 static const std::string TEST_LINK_FILE_PATH = MOUNT_POINT_DIR + "/" + TEST_LINK_FILE_NAME;
60 static int32_t g_mountFd = -1;
61 static const std::string DEFAULT_CURRENT_ACCOUNT = "ohosAnonymousName";
62 static const uint8_t ARRAY_CHAR_SIZE = 62;
63 static const char CHAR_ARRAY[] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
64 static const int32_t TEST_USER_COUNT = 2;
65 static const int32_t RAND_STR_SIZE = 16;
66 static const int32_t EXPIRT_TIME = 10000;
67 static int g_plainFileFd = -1;
68 static int g_dlpFileFd = -1;
69 static int g_recoveryFileFd = -1;
70 static std::shared_ptr<DlpFile> g_Dlpfile = nullptr;
71 static const int32_t DEFAULT_USERID = 100;
72 static AccessTokenID g_selfTokenId = 0;
73 constexpr int SIX = 6;
74 constexpr int SIXTEEN = 16;
75 constexpr int EIGHTEEN = 18;
76 }
77 
SetUpTestCase()78 void DlpFuseTest::SetUpTestCase()
79 {
80     g_selfTokenId = GetSelfTokenID();
81     AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(DEFAULT_USERID, "com.ohos.dlpmanager", 0);
82     SetSelfTokenID(tokenId);
83     struct stat fstat;
84     if (stat(DLP_TEST_DIR.c_str(), &fstat) != 0) {
85         if (errno == ENOENT) {
86             int32_t ret = mkdir(DLP_TEST_DIR.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
87             if (ret < 0) {
88                 DLP_LOG_ERROR(LABEL, "mkdir mount point failed errno %{public}d", errno);
89                 return;
90             }
91         } else {
92             DLP_LOG_ERROR(LABEL, "get mount point failed errno %{public}d", errno);
93             return;
94         }
95     }
96 }
97 
TearDownTestCase()98 void DlpFuseTest::TearDownTestCase()
99 {
100     g_mountFd = -1;
101     int ret = umount(MOUNT_POINT_DIR.c_str());
102     DLP_LOG_INFO(LABEL, "umount ret=%{public}d error=%{public}s", ret, strerror(errno));
103     rmdir(MOUNT_POINT_DIR.c_str());
104     rmdir(DLP_TEST_DIR.c_str());
105 
106     SetSelfTokenID(g_selfTokenId);
107 }
108 
SetUp()109 void DlpFuseTest::SetUp()
110 {}
111 
TearDown()112 void DlpFuseTest::TearDown()
113 {
114     DLP_LOG_INFO(LABEL, "TearDown");
115     for (uint32_t i = 0; i < LINK_FD_ARRY_SIZE; i++) {
116         if (g_linkFdArry[i] != -1) {
117             close(g_linkFdArry[i]);
118             g_linkFdArry[i] = -1;
119         }
120     }
121     if (g_plainFileFd != -1) {
122         close(g_plainFileFd);
123         g_plainFileFd = -1;
124     }
125     if (g_dlpFileFd != -1) {
126         close(g_dlpFileFd);
127         g_dlpFileFd = -1;
128     }
129     if (g_recoveryFileFd != -1) {
130         close(g_recoveryFileFd);
131         g_recoveryFileFd = -1;
132     }
133 
134     if (g_Dlpfile != nullptr) {
135         DlpFileManager::GetInstance().CloseDlpFile(g_Dlpfile);
136         g_Dlpfile = nullptr;
137     }
138     DLP_LOG_INFO(LABEL, "TearDown end");
139 }
140 
141 namespace {
GetRandNum()142 static uint8_t GetRandNum()
143 {
144     uint8_t rand;
145     RAND_bytes(reinterpret_cast<unsigned char *>(&rand), sizeof(rand));
146     return rand;
147 }
148 
GenerateRandStr(uint32_t len,std::string & res)149 static void GenerateRandStr(uint32_t len, std::string& res)
150 {
151     for (uint32_t i = 0; i < len; i++) {
152         uint32_t index = GetRandNum() % ARRAY_CHAR_SIZE;
153         res.push_back(CHAR_ARRAY[index]);
154     }
155 }
156 
GenerateRandProperty(struct DlpProperty & encProp)157 static void GenerateRandProperty(struct DlpProperty& encProp)
158 {
159     uint64_t curTime = static_cast<uint64_t>(
160         std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count());
161     encProp.ownerAccount = DEFAULT_CURRENT_ACCOUNT;
162     encProp.ownerAccountId = DEFAULT_CURRENT_ACCOUNT;
163     encProp.ownerAccountType = CLOUD_ACCOUNT;
164     for (uint32_t user = 0; user < TEST_USER_COUNT; ++user) {
165         std::string accountName;
166         GenerateRandStr(RAND_STR_SIZE, accountName);
167         AuthUserInfo perminfo = {.authAccount = strdup(const_cast<char *>(accountName.c_str())),
168             .authPerm = READ_ONLY,
169             .permExpiryTime = curTime + EXPIRT_TIME,
170             .authAccountType = CLOUD_ACCOUNT};
171         encProp.authUsers.emplace_back(perminfo);
172     }
173     std::string accountName;
174     GenerateRandStr(RAND_STR_SIZE, accountName);
175     encProp.contactAccount = strdup(const_cast<char *>(accountName.c_str()));
176 }
177 
PrepareDlpFuseFsMount()178 void PrepareDlpFuseFsMount()
179 {
180     struct stat fstat;
181     if (stat(MOUNT_POINT_DIR.c_str(), &fstat) != 0) {
182         if (errno == ENOENT) {
183             int32_t ret = mkdir(MOUNT_POINT_DIR.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
184             if (ret < 0) {
185                 DLP_LOG_ERROR(LABEL, "mkdir mount point failed errno %{public}d", errno);
186                 return;
187             }
188         } else {
189             DLP_LOG_ERROR(LABEL, "get mount point failed errno %{public}d", errno);
190             return;
191         }
192     }
193 
194     g_mountFd = open(FUSE_DEV.c_str(), O_RDWR);
195     if (g_mountFd == -1) {
196         if (errno == ENODEV || errno == ENOENT) {
197             DLP_LOG_ERROR(LABEL, "fuse device not found.");
198         } else {
199             DLP_LOG_ERROR(LABEL, "open fuse device failed.");
200         }
201         return;
202     }
203     SetDlpFuseFd(g_mountFd);
204     std::string source = FUSE_DEV;
205     std::string mnt = MOUNT_POINT_DIR;
206     std::string type = FUSE_TYPE;
207 
208     char kernelOpts[KERNEL_OPT_MAXLEN] = "";
209     (void)snprintf_s(kernelOpts, KERNEL_OPT_MAXLEN, KERNEL_OPT_MAXLEN - 1,
210         "fd=%d,rootmode=40000,user_id=%u,group_id=%u", g_mountFd, getuid(), getgid());
211     DLP_LOG_INFO(LABEL, "kernelOpts %{public}s", kernelOpts);
212 
213     int32_t res = mount(source.c_str(), mnt.c_str(), type.c_str(), MS_NOSUID | MS_NODEV, kernelOpts);
214     if (res != 0) {
215         DLP_LOG_ERROR(LABEL, "mount failed, errno %{public}d", errno);
216     }
217 }
218 
CheckLinkFd(int32_t linkfd1)219 void CheckLinkFd(int32_t linkfd1)
220 {
221     DLP_LOG_INFO(LABEL, "CheckLinkFd");
222     // offset 0 size 6
223     char readBuf[64] = {0};
224     ASSERT_NE(lseek(linkfd1, 0, SEEK_SET), -1);
225     ASSERT_EQ(read(linkfd1, readBuf, SIX), SIX);
226     ASSERT_EQ(strcmp(readBuf, "123456"), 0);
227     // read hole data, offset 0x1000 size 6
228     memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
229     ASSERT_NE(lseek(linkfd1, 0x1000, SEEK_SET), -1);
230     ASSERT_GE(read(linkfd1, readBuf, SIX), SIX);
231     char zeroBuf[6] = { 0 };
232     ASSERT_EQ(memcmp(readBuf, zeroBuf, SIX), 0);
233     // offset 1M size 6
234     memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
235     ASSERT_NE(lseek(linkfd1, 0x100000, SEEK_SET), -1);
236     ASSERT_EQ(read(linkfd1, readBuf, SIX), SIX);
237     ASSERT_EQ(strcmp(readBuf, "123456"), 0);
238     // offset 1m+16 size 16
239     memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
240     ASSERT_NE(lseek(linkfd1, 0x100010, SEEK_SET), -1);
241     ASSERT_EQ(read(linkfd1, readBuf, SIXTEEN), SIXTEEN);
242     ASSERT_EQ(strcmp(readBuf, "1234567890123456"), 0);
243     // offset 1m+34 size 6
244     memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
245     ASSERT_NE(lseek(linkfd1, 0x100022, SEEK_SET), -1);
246     ASSERT_EQ(read(linkfd1, readBuf, SIX), SIX);
247     ASSERT_EQ(strcmp(readBuf, "123456"), 0);
248     // offset 1m+47 size 6
249     memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
250     ASSERT_NE(lseek(linkfd1, 0x10002f, SEEK_SET), -1);
251     ASSERT_EQ(read(linkfd1, readBuf, SIX), SIX);
252     ASSERT_EQ(strcmp(readBuf, "123456"), 0);
253     // offset 1m+63 size 18
254     memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
255     ASSERT_NE(lseek(linkfd1, 0x10003f, SEEK_SET), -1);
256     ASSERT_EQ(read(linkfd1, readBuf, EIGHTEEN), EIGHTEEN);
257     ASSERT_EQ(strcmp(readBuf, "1234567890abcdefgh"), 0);
258 }
259 
CheckRecoverFd()260 void CheckRecoverFd()
261 {
262     DLP_LOG_INFO(LABEL, "CheckRecoverFd");
263     // offset 0 size 6
264     char readBuf[64] = {0};
265     ASSERT_NE(lseek(g_recoveryFileFd, 0, SEEK_SET), -1);
266     ASSERT_EQ(read(g_recoveryFileFd, readBuf, SIX), SIX);
267     ASSERT_EQ(strcmp(readBuf, "123456"), 0);
268 
269     // read hole data, offset 0x1000 size 6
270     memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
271     ASSERT_NE(lseek(g_recoveryFileFd, 0x1000, SEEK_SET), -1);
272     ASSERT_GE(read(g_recoveryFileFd, readBuf, SIX), SIX);
273     char zeroBuf[6] = { 0 };
274     ASSERT_EQ(memcmp(readBuf, zeroBuf, SIX), 0);
275 
276     // offset 1M size 6
277     memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
278     ASSERT_NE(lseek(g_recoveryFileFd, 0x100000, SEEK_SET), -1);
279     ASSERT_EQ(read(g_recoveryFileFd, readBuf, SIX), SIX);
280     ASSERT_EQ(strcmp(readBuf, "123456"), 0);
281 
282     // offset 1m+16 size 16
283     memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
284     ASSERT_NE(lseek(g_recoveryFileFd, 0x100010, SEEK_SET), -1);
285     ASSERT_EQ(read(g_recoveryFileFd, readBuf, SIXTEEN), SIXTEEN);
286     ASSERT_EQ(strcmp(readBuf, "1234567890123456"), 0);
287 
288     // offset 1m+34 size 6
289     memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
290     ASSERT_NE(lseek(g_recoveryFileFd, 0x100022, SEEK_SET), -1);
291     ASSERT_EQ(read(g_recoveryFileFd, readBuf, SIX), SIX);
292     ASSERT_EQ(strcmp(readBuf, "123456"), 0);
293 
294     // offset 1m+47 size 6
295     memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
296     ASSERT_NE(lseek(g_recoveryFileFd, 0x10002f, SEEK_SET), -1);
297     ASSERT_EQ(read(g_recoveryFileFd, readBuf, SIX), SIX);
298     ASSERT_EQ(strcmp(readBuf, "123456"), 0);
299 
300     // offset 1m+63 size 18
301     memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
302     ASSERT_NE(lseek(g_recoveryFileFd, 0x10003f, SEEK_SET), -1);
303     ASSERT_EQ(read(g_recoveryFileFd, readBuf, EIGHTEEN), EIGHTEEN);
304     ASSERT_EQ(strcmp(readBuf, "1234567890abcdefgh"), 0);
305 }
306 }
307 
308 /**
309  * @tc.name: AddDlpLinkFile001
310  * @tc.desc: test dlp link file read
311  * @tc.type: FUNC
312  * @tc.require:AR000GVIGC
313  */
314 HWTEST_F(DlpFuseTest, AddDlpLinkFile001, TestSize.Level1)
315 {
316     DLP_LOG_INFO(LABEL, "AddDlpLinkFile001");
317     PrepareDlpFuseFsMount();
318     g_plainFileFd = open("/data/fuse_test.txt", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
319     g_dlpFileFd = open("/data/fuse_test.txt.dlp", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
320     ASSERT_GE(g_plainFileFd, 0);
321     ASSERT_GE(g_dlpFileFd, 0);
322 
323     char buffer[] = "123456";
324     ASSERT_NE(write(g_plainFileFd, buffer, sizeof(buffer)), -1);
325     ASSERT_NE(lseek(g_plainFileFd, 0x100000, SEEK_SET), -1);
326     ASSERT_NE(write(g_plainFileFd, buffer, sizeof(buffer)), -1);
327     ASSERT_NE(lseek(g_plainFileFd, 0x10000f, SEEK_SET), -1);
328     ASSERT_NE(write(g_plainFileFd, "1234567890abcdefgh", strlen("1234567890abcdefgh")), -1);
329 
330     struct DlpProperty prop;
331     GenerateRandProperty(prop);
332     ASSERT_EQ(DlpFileManager::GetInstance().GenerateDlpFile(g_plainFileFd,
333         g_dlpFileFd, prop, g_Dlpfile, DLP_TEST_DIR), 0);
334     ASSERT_NE(g_Dlpfile, nullptr);
335     ASSERT_EQ(DlpLinkManager::GetInstance().AddDlpLinkFile(g_Dlpfile, TEST_LINK_FILE_NAME), 0);
336     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_[TEST_LINK_FILE_NAME]->hasRead_ = true;
337     // open link file
338     int32_t linkfd = open(TEST_LINK_FILE_PATH.c_str(), O_RDWR);
339     ASSERT_GE(linkfd, 0);
340     g_linkFdArry[0] = linkfd;
341 
342     char readBuf[64] = {0};
343     ASSERT_GE(read(linkfd, readBuf, 6), 6);
344     ASSERT_EQ(strcmp(readBuf, "123456"), 0);
345 
346     memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
347     ASSERT_GE(lseek(linkfd, 0x100000, SEEK_SET), 0);
348     ASSERT_EQ(read(linkfd, readBuf, 6), 6);
349     ASSERT_EQ(strcmp(readBuf, "123456"), 0);
350 
351     memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
352     ASSERT_GE(lseek(linkfd, 0x10000f, SEEK_SET), 0);
353     ASSERT_EQ(read(linkfd, readBuf, 18), 18);
354     ASSERT_EQ(strcmp(readBuf, "1234567890abcdefgh"), 0);
355 
356     memset_s(readBuf, sizeof(readBuf), 0, sizeof(readBuf));
357     ASSERT_GE(lseek(linkfd, 0x100021, SEEK_SET), 0);
358     ASSERT_EQ(read(linkfd, readBuf, 6), 0);
359     close(linkfd);
360     g_linkFdArry[0] = 0;
361 
362     ASSERT_EQ(DlpLinkManager::GetInstance().DeleteDlpLinkFile(g_Dlpfile), 0);
363     ASSERT_EQ(DlpFileManager::GetInstance().CloseDlpFile(g_Dlpfile), 0);
364     g_Dlpfile = nullptr;
365 }
366 
367 /**
368  * @tc.name: AddDlpLinkFile002
369  * @tc.desc: test dlp fuse write and check it from recovery file
370  * @tc.type: FUNC
371  * @tc.require:AR000GVIGC
372  */
373 HWTEST_F(DlpFuseTest, AddDlpLinkFile002, TestSize.Level1)
374 {
375     DLP_LOG_INFO(LABEL, "AddDlpLinkFile002");
376     g_plainFileFd = open("/data/fuse_test.txt", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
377     g_dlpFileFd = open("/data/fuse_test.txt.dlp", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
378     ASSERT_GE(g_plainFileFd, 0);
379     ASSERT_GE(g_dlpFileFd, 0);
380 
381     char buffer[] = "111111";
382     ASSERT_NE(write(g_plainFileFd, buffer, strlen("111111")), -1);
383 
384     struct DlpProperty prop;
385     GenerateRandProperty(prop);
386     ASSERT_EQ(DlpFileManager::GetInstance().GenerateDlpFile(g_plainFileFd,
387         g_dlpFileFd, prop, g_Dlpfile, DLP_TEST_DIR), 0);
388     ASSERT_NE(g_Dlpfile, nullptr);
389 
390     ASSERT_EQ(DlpLinkManager::GetInstance().AddDlpLinkFile(g_Dlpfile, TEST_LINK_FILE_NAME), 0);
391     // open link file
392     int32_t linkfd = open(TEST_LINK_FILE_PATH.c_str(), O_RDWR);
393     ASSERT_GE(linkfd, 0);
394     g_linkFdArry[0] = linkfd;
395     g_Dlpfile->authPerm_ = FULL_CONTROL;
396     // offset 0 size 6
397     ASSERT_NE(write(linkfd, "123456", strlen("123456")), -1);
398     // offset 1M size 6
399     ASSERT_NE(lseek(linkfd, 0x100000, SEEK_SET), -1);
400     ASSERT_NE(write(linkfd, "123456", strlen("123456")), -1);
401     // offset 1m+16 size 16
402     ASSERT_NE(lseek(linkfd, 0x100010, SEEK_SET), -1);
403     ASSERT_NE(write(linkfd, "1234567890123456", strlen("1234567890123456")), -1);
404     // offset 1m+34 size 6
405     ASSERT_NE(lseek(linkfd, 0x100022, SEEK_SET), -1);
406     ASSERT_NE(write(linkfd, "123456", strlen("123456")), -1);
407     // offset 1m+47 size 6
408     ASSERT_NE(lseek(linkfd, 0x10002f, SEEK_SET), -1);
409     ASSERT_NE(write(linkfd, "123456", strlen("123456")), -1);
410     // offset 1m+63 size 18
411     ASSERT_NE(lseek(linkfd, 0x10003f, SEEK_SET), -1);
412     ASSERT_NE(write(linkfd, "1234567890abcdefgh", strlen("1234567890abcdefgh")), -1);
413     close(linkfd);
414     g_linkFdArry[0] = 0;
415     ASSERT_EQ(DlpLinkManager::GetInstance().DeleteDlpLinkFile(g_Dlpfile), 0);
416 
417     g_recoveryFileFd = open("/data/fuse_test.txt.recovery", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
418     ASSERT_GE(g_dlpFileFd, 0);
419     g_Dlpfile->authPerm_ = FULL_CONTROL;
420     ASSERT_EQ(DlpFileManager::GetInstance().RecoverDlpFile(g_Dlpfile, g_recoveryFileFd), 0);
421     ASSERT_EQ(DlpFileManager::GetInstance().CloseDlpFile(g_Dlpfile), 0);
422     g_Dlpfile = nullptr;
423     CheckRecoverFd();
424 }
425 
426 /**
427  * @tc.name: AddDlpLinkFile003
428  * @tc.desc: test dlp link read after write
429  * @tc.type: FUNC
430  * @tc.require:AR000GVIGC
431  */
432 HWTEST_F(DlpFuseTest, AddDlpLinkFile003, TestSize.Level1)
433 {
434     DLP_LOG_INFO(LABEL, "AddDlpLinkFile003");
435     g_plainFileFd = open("/data/fuse_test.txt", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
436     g_dlpFileFd = open("/data/fuse_test.txt.dlp", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
437     ASSERT_GE(g_plainFileFd, 0);
438     ASSERT_GE(g_dlpFileFd, 0);
439 
440     struct DlpProperty prop;
441     GenerateRandProperty(prop);
442 
443     ASSERT_EQ(DlpFileManager::GetInstance().GenerateDlpFile(g_plainFileFd,
444         g_dlpFileFd, prop, g_Dlpfile, DLP_TEST_DIR), 0);
445     ASSERT_NE(g_Dlpfile, nullptr);
446     ASSERT_EQ(DlpLinkManager::GetInstance().AddDlpLinkFile(g_Dlpfile, TEST_LINK_FILE_NAME), 0);
447 
448     // open link file
449     int32_t linkfd = open(TEST_LINK_FILE_PATH.c_str(), O_RDWR);
450     ASSERT_GE(linkfd, 0);
451     g_linkFdArry[0] = linkfd;
452 
453     // offset 0 size 6
454     ASSERT_NE(write(linkfd, "123456", strlen("123456")), -1);
455 
456     // offset 1M size 6
457     ASSERT_NE(lseek(linkfd, 0x100000, SEEK_SET), -1);
458     ASSERT_NE(write(linkfd, "123456", strlen("123456")), -1);
459 
460     // offset 1m+16 size 16
461     ASSERT_NE(lseek(linkfd, 0x100010, SEEK_SET), -1);
462     ASSERT_NE(write(linkfd, "1234567890123456", strlen("1234567890123456")), -1);
463 
464     // offset 1m+34 size 6
465     ASSERT_NE(lseek(linkfd, 0x100022, SEEK_SET), -1);
466     ASSERT_NE(write(linkfd, "123456", strlen("123456")), -1);
467 
468     // offset 1m+47 size 6
469     ASSERT_NE(lseek(linkfd, 0x10002f, SEEK_SET), -1);
470     ASSERT_NE(write(linkfd, "123456", strlen("123456")), -1);
471 
472     // offset 1m+63 size 18
473     ASSERT_NE(lseek(linkfd, 0x10003f, SEEK_SET), -1);
474     ASSERT_NE(write(linkfd, "1234567890abcdefgh", strlen("1234567890abcdefgh")), -1);
475 
476     CheckLinkFd(linkfd);
477     close(linkfd);
478     ASSERT_EQ(DlpLinkManager::GetInstance().DeleteDlpLinkFile(g_Dlpfile), 0);
479     ASSERT_EQ(DlpFileManager::GetInstance().CloseDlpFile(g_Dlpfile), 0);
480     g_Dlpfile = nullptr;
481 }
482 
483 /**
484  * @tc.name: AddDlpLinkFile004
485  * @tc.desc: test dlp link file stat
486  * @tc.type: FUNC
487  * @tc.require:AR000GVIGC
488  */
489 HWTEST_F(DlpFuseTest, AddDlpLinkFile004, TestSize.Level1)
490 {
491     DLP_LOG_INFO(LABEL, "AddDlpLinkFile004");
492     g_plainFileFd = open("/data/fuse_test.txt", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
493     g_dlpFileFd = open("/data/fuse_test.txt.dlp", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
494     ASSERT_GE(g_plainFileFd, 0);
495     ASSERT_GE(g_dlpFileFd, 0);
496 
497     char buffer[] = "123456";
498     ASSERT_NE(write(g_plainFileFd, buffer, strlen("123456")), -1);
499 
500     struct DlpProperty prop;
501     GenerateRandProperty(prop);
502 
503     ASSERT_EQ(DlpFileManager::GetInstance().GenerateDlpFile(g_plainFileFd,
504         g_dlpFileFd, prop, g_Dlpfile, DLP_TEST_DIR), 0);
505     ASSERT_NE(g_Dlpfile, nullptr);
506     ASSERT_EQ(DlpLinkManager::GetInstance().AddDlpLinkFile(g_Dlpfile, TEST_LINK_FILE_NAME), 0);
507 
508     // open link file
509     int32_t linkfd = open(TEST_LINK_FILE_PATH.c_str(), O_RDWR);
510     ASSERT_GE(linkfd, 0);
511     g_linkFdArry[0] = linkfd;
512 
513     struct stat fsStat;
514     ASSERT_EQ(fstat(linkfd, &fsStat), 0);
515     ASSERT_EQ(fsStat.st_size, 6);
516 
517     close(linkfd);
518     g_linkFdArry[0] = 0;
519 
520     ASSERT_EQ(DlpLinkManager::GetInstance().DeleteDlpLinkFile(g_Dlpfile), 0);
521     ASSERT_EQ(DlpFileManager::GetInstance().CloseDlpFile(g_Dlpfile), 0);
522     g_Dlpfile = nullptr;
523 }
524 
525 /**
526  * @tc.name: AddDlpLinkFile005
527  * @tc.desc: test dlp link file open with trunc
528  * @tc.type: FUNC
529  * @tc.require:AR000GVIGC
530  */
531 HWTEST_F(DlpFuseTest, AddDlpLinkFile005, TestSize.Level1)
532 {
533     DLP_LOG_INFO(LABEL, "AddDlpLinkFile005");
534     g_plainFileFd = open("/data/fuse_test.txt", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
535     g_dlpFileFd = open("/data/fuse_test.txt.dlp", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
536     ASSERT_GE(g_plainFileFd, 0);
537     ASSERT_GE(g_dlpFileFd, 0);
538 
539     char buffer[] = "123456";
540     ASSERT_NE(write(g_plainFileFd, buffer, strlen("123456")), -1);
541 
542     struct DlpProperty prop;
543     GenerateRandProperty(prop);
544 
545     ASSERT_EQ(DlpFileManager::GetInstance().GenerateDlpFile(g_plainFileFd,
546         g_dlpFileFd, prop, g_Dlpfile, DLP_TEST_DIR), 0);
547     ASSERT_NE(g_Dlpfile, nullptr);
548     g_Dlpfile->authPerm_ = FULL_CONTROL;
549     ASSERT_EQ(DlpLinkManager::GetInstance().AddDlpLinkFile(g_Dlpfile, TEST_LINK_FILE_NAME), 0);
550 
551     // open link file
552     int32_t linkfd = open(TEST_LINK_FILE_PATH.c_str(), O_RDWR | O_TRUNC);
553     ASSERT_GE(linkfd, 0);
554     g_linkFdArry[0] = linkfd;
555 
556     struct stat fsStat;
557     ASSERT_EQ(fstat(linkfd, &fsStat), 0);
558     ASSERT_EQ(fsStat.st_size, 0);
559 
560     close(linkfd);
561     g_linkFdArry[0] = 0;
562 
563     ASSERT_EQ(DlpLinkManager::GetInstance().DeleteDlpLinkFile(g_Dlpfile), 0);
564     ASSERT_EQ(DlpFileManager::GetInstance().CloseDlpFile(g_Dlpfile), 0);
565     g_Dlpfile = nullptr;
566 }
567 
568 /**
569  * @tc.name: AddDlpLinkFile006
570  * @tc.desc: test dlp link file open with trunc
571  * @tc.type: FUNC
572  * @tc.require:AR000GVIGC
573  */
574 HWTEST_F(DlpFuseTest, AddDlpLinkFile006, TestSize.Level1)
575 {
576     DLP_LOG_INFO(LABEL, "AddDlpLinkFile006");
577     g_plainFileFd = open("/data/fuse_test.txt", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
578     g_dlpFileFd = open("/data/fuse_test.txt.dlp", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
579     ASSERT_GE(g_plainFileFd, 0);
580     ASSERT_GE(g_dlpFileFd, 0);
581 
582     char buffer[] = "123456";
583     ASSERT_NE(write(g_plainFileFd, buffer, strlen("123456")), -1);
584 
585     struct DlpProperty prop;
586     GenerateRandProperty(prop);
587 
588     ASSERT_EQ(DlpFileManager::GetInstance().GenerateDlpFile(g_plainFileFd,
589         g_dlpFileFd, prop, g_Dlpfile, DLP_TEST_DIR), 0);
590     ASSERT_NE(g_Dlpfile, nullptr);
591     ASSERT_EQ(DlpLinkManager::GetInstance().AddDlpLinkFile(g_Dlpfile, TEST_LINK_FILE_NAME), 0);
592     g_Dlpfile->authPerm_ = FULL_CONTROL;
593     // open link file
594     int32_t linkfd = open(TEST_LINK_FILE_PATH.c_str(), O_RDWR | O_TRUNC);
595     ASSERT_GE(linkfd, 0);
596     g_linkFdArry[0] = linkfd;
597 
598     // get link file size
599     struct stat fsStat;
600     ASSERT_EQ(fstat(linkfd, &fsStat), 0);
601     ASSERT_EQ(fsStat.st_size, 0);
602     close(linkfd);
603     g_linkFdArry[0] = 0;
604     ASSERT_EQ(DlpLinkManager::GetInstance().DeleteDlpLinkFile(g_Dlpfile), 0);
605 
606     g_recoveryFileFd = open("/data/fuse_test.txt.recovery", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
607     ASSERT_GE(g_dlpFileFd, 0);
608     ASSERT_EQ(DlpFileManager::GetInstance().RecoverDlpFile(g_Dlpfile, g_recoveryFileFd), 0);
609     ASSERT_EQ(DlpFileManager::GetInstance().CloseDlpFile(g_Dlpfile), 0);
610     g_Dlpfile = nullptr;
611 
612     ASSERT_EQ(fstat(g_recoveryFileFd, &fsStat), 0);
613     ASSERT_EQ(fsStat.st_size, 0);
614     close(g_recoveryFileFd);
615     g_recoveryFileFd = 0;
616 }
617 
618 /**
619  * @tc.name: AddDlpLinkFile007
620  * @tc.desc: test dlp link file truncate
621  * @tc.type: FUNC
622  * @tc.require:AR000GVIGC
623  */
624 HWTEST_F(DlpFuseTest, AddDlpLinkFile007, TestSize.Level1)
625 {
626     DLP_LOG_INFO(LABEL, "AddDlpLinkFile007");
627     g_plainFileFd = open("/data/fuse_test.txt", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
628     g_dlpFileFd = open("/data/fuse_test.txt.dlp", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
629     ASSERT_GE(g_plainFileFd, 0);
630     ASSERT_GE(g_dlpFileFd, 0);
631 
632     char buffer[] = "123456";
633     ASSERT_NE(write(g_plainFileFd, buffer, strlen("123456")), -1);
634 
635     struct DlpProperty prop;
636     GenerateRandProperty(prop);
637 
638     ASSERT_EQ(DlpFileManager::GetInstance().GenerateDlpFile(g_plainFileFd,
639         g_dlpFileFd, prop, g_Dlpfile, DLP_TEST_DIR), 0);
640     ASSERT_NE(g_Dlpfile, nullptr);
641     ASSERT_EQ(DlpLinkManager::GetInstance().AddDlpLinkFile(g_Dlpfile, TEST_LINK_FILE_NAME), 0);
642 
643     // open link file
644     int32_t linkfd = open(TEST_LINK_FILE_PATH.c_str(), O_RDWR);
645     ASSERT_GE(linkfd, 0);
646     g_linkFdArry[0] = linkfd;
647     g_Dlpfile->authPerm_ = FULL_CONTROL;
648     // truncate link file size to 3
649     ASSERT_EQ(ftruncate(linkfd, 3), 0);
650 
651     // get link file size
652     struct stat fsStat;
653     ASSERT_EQ(fstat(linkfd, &fsStat), 0);
654     ASSERT_EQ(fsStat.st_size, 3);
655     close(linkfd);
656     g_linkFdArry[0] = 0;
657     ASSERT_EQ(DlpLinkManager::GetInstance().DeleteDlpLinkFile(g_Dlpfile), 0);
658 
659     g_recoveryFileFd = open("/data/fuse_test.txt.recovery", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
660     ASSERT_GE(g_dlpFileFd, 0);
661     ASSERT_EQ(DlpFileManager::GetInstance().RecoverDlpFile(g_Dlpfile, g_recoveryFileFd), 0);
662     ASSERT_EQ(DlpFileManager::GetInstance().CloseDlpFile(g_Dlpfile), 0);
663     g_Dlpfile = nullptr;
664 
665     ASSERT_EQ(fstat(g_recoveryFileFd, &fsStat), 0);
666     ASSERT_EQ(fsStat.st_size, 3);
667 
668     char readBuf[64] = {0};
669     ASSERT_NE(lseek(g_recoveryFileFd, 0, SEEK_SET), -1);
670     ASSERT_EQ(read(g_recoveryFileFd, readBuf, 6), 3);
671     ASSERT_EQ(strcmp(readBuf, "123"), 0);
672     close(g_recoveryFileFd);
673     g_recoveryFileFd = 0;
674 }
675 
676 /**
677  * @tc.name: AddDlpLinkFile008
678  * @tc.desc: test dlp link file changed size, dlp header txtSize also changed
679  * @tc.type: FUNC
680  * @tc.require:AR000GVIGC
681  */
682 HWTEST_F(DlpFuseTest, AddDlpLinkFile008, TestSize.Level1)
683 {
684     DLP_LOG_INFO(LABEL, "AddDlpLinkFile008");
685     g_plainFileFd = open("/data/fuse_test.txt", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
686     g_dlpFileFd = open("/data/fuse_test.txt.dlp", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
687     ASSERT_GE(g_plainFileFd, 0);
688     ASSERT_GE(g_dlpFileFd, 0);
689 
690     char buffer[] = "123456";
691     ASSERT_NE(write(g_plainFileFd, buffer, strlen("123456")), -1);
692 
693     struct DlpProperty prop;
694     GenerateRandProperty(prop);
695 
696     ASSERT_EQ(DlpFileManager::GetInstance().GenerateDlpFile(g_plainFileFd,
697         g_dlpFileFd, prop, g_Dlpfile, DLP_TEST_DIR), 0);
698     ASSERT_NE(g_Dlpfile, nullptr);
699     ASSERT_EQ(DlpLinkManager::GetInstance().AddDlpLinkFile(g_Dlpfile, TEST_LINK_FILE_NAME), 0);
700 
701     // open link file
702     int32_t linkfd = open(TEST_LINK_FILE_PATH.c_str(), O_RDWR);
703     ASSERT_GE(linkfd, 0);
704     g_linkFdArry[0] = linkfd;
705     g_Dlpfile->authPerm_ = FULL_CONTROL;
706     // truncate link file size to 3
707     ASSERT_EQ(ftruncate(linkfd, 3), 0);
708 
709     // dlp header txtSize will 4
710     ASSERT_NE(lseek(linkfd, 3, SEEK_SET), -1);
711     ASSERT_NE(write(linkfd, "1", strlen("1")), -1);
712 
713     // write back cache enable, need fsync
714     fsync(linkfd);
715     close(linkfd);
716 
717     g_linkFdArry[0] = 0;
718     ASSERT_EQ(DlpLinkManager::GetInstance().DeleteDlpLinkFile(g_Dlpfile), 0);
719     ASSERT_EQ(DlpFileManager::GetInstance().CloseDlpFile(g_Dlpfile), 0);
720     g_Dlpfile = nullptr;
721 }
722 
723 /**
724  * @tc.name: AddDlpLinkFile009
725  * @tc.desc: test add link abnoral branch
726  * @tc.type: FUNC
727  * @tc.require:AR000GVIGC
728  */
729 HWTEST_F(DlpFuseTest, AddDlpLinkFile009, TestSize.Level1)
730 {
731     DLP_LOG_INFO(LABEL, "AddDlpLinkFile009");
732     std::shared_ptr<DlpFile> filePtr = nullptr;
733     EXPECT_EQ(DlpLinkManager::GetInstance().AddDlpLinkFile(filePtr, ""), DLP_FUSE_ERROR_DLP_FILE_NULL);
734 
735     filePtr = std::make_shared<DlpFile>(1000, DLP_TEST_DIR, 0, false);
736     EXPECT_EQ(DlpLinkManager::GetInstance().AddDlpLinkFile(filePtr, ""), DLP_FUSE_ERROR_VALUE_INVALID);
737 
738     EXPECT_EQ(DlpLinkManager::GetInstance().AddDlpLinkFile(filePtr, "linkfile"), DLP_OK);
739     EXPECT_EQ(DlpLinkManager::GetInstance().AddDlpLinkFile(filePtr, "linkfile"), DLP_FUSE_ERROR_LINKFILE_EXIST);
740 
741     DlpLinkManager::GetInstance().DeleteDlpLinkFile(filePtr);
742 }
743 
744 /**
745  * @tc.name: AddDlpLinkFile010
746  * @tc.desc: test add too many links
747  * @tc.type: FUNC
748  * @tc.require:AR000GVIGC
749  */
750 HWTEST_F(DlpFuseTest, AddDlpLinkFile010, TestSize.Level1)
751 {
752     DLP_LOG_INFO(LABEL, "AddDlpLinkFile010");
753     std::shared_ptr<DlpFile> filePtr = std::make_shared<DlpFile>(-1, DLP_TEST_DIR, 0, false);
754     ASSERT_NE(filePtr, nullptr);
755     for (int i = 0; i < 1000; i++) {
756         std::string linkName = "AddDlpLinkFile010-" + std::to_string(i);
757         std::shared_ptr<DlpFile> filePtr2 = std::make_shared<DlpFile>(-i, DLP_TEST_DIR, 0, false);
758         DlpLinkManager::GetInstance().AddDlpLinkFile(filePtr2, linkName);
759     }
760     EXPECT_EQ(DlpLinkManager::GetInstance().AddDlpLinkFile(filePtr, "linkfile"), DLP_FUSE_ERROR_TOO_MANY_LINK_FILE);
761     for (int i = 0; i < 1000; i++) {
762         DlpLinkManager::GetInstance().DeleteDlpLinkFile(filePtr);
763     }
764     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_.clear();
765 }
766 
767 /**
768  * @tc.name: DeleteDlpLinkFile001
769  * @tc.desc: test delete link abnoral branch
770  * @tc.type: FUNC
771  * @tc.require:AR000GVIGC
772  */
773 HWTEST_F(DlpFuseTest, DeleteDlpLinkFile001, TestSize.Level1)
774 {
775     DLP_LOG_INFO(LABEL, "DeleteDlpLinkFile001");
776     std::shared_ptr<DlpFile> filePtr = nullptr;
777     EXPECT_EQ(DlpLinkManager::GetInstance().DeleteDlpLinkFile(filePtr), DLP_FUSE_ERROR_DLP_FILE_NULL);
778 
779     filePtr = std::make_shared<DlpFile>(1000, DLP_TEST_DIR, 0, false);
780     ASSERT_NE(filePtr, nullptr);
781     EXPECT_EQ(DlpLinkManager::GetInstance().DeleteDlpLinkFile(filePtr), DLP_FUSE_ERROR_LINKFILE_NOT_EXIST);
782 
783     DlpLinkFile *node = new (std::nothrow) DlpLinkFile("linkfile", nullptr);
784     ASSERT_NE(node, nullptr);
785     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_["null"] = nullptr;
786     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_["linkfile"] = node;
787 
788     EXPECT_EQ(DlpLinkManager::GetInstance().DeleteDlpLinkFile(filePtr), DLP_FUSE_ERROR_LINKFILE_NOT_EXIST);
789     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_.erase("null");
790     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_.erase("linkfile");
791     delete(node);
792 }
793 
794 /**
795  * @tc.name: LookUpDlpLinkFile001
796  * @tc.desc: test lookup link abnoral branch
797  * @tc.type: FUNC
798  * @tc.require:AR000GVIGC
799  */
800 HWTEST_F(DlpFuseTest, LookUpDlpLinkFile001, TestSize.Level1)
801 {
802     DLP_LOG_INFO(LABEL, "LookUpDlpLinkFile001");
803     EXPECT_EQ(DlpLinkManager::GetInstance().LookUpDlpLinkFile(""), nullptr);
804     EXPECT_EQ(DlpLinkManager::GetInstance().LookUpDlpLinkFile("linkfile"), nullptr);
805     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_["linkfile"] = nullptr;
806     EXPECT_EQ(DlpLinkManager::GetInstance().LookUpDlpLinkFile("linkfile"), nullptr);
807     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_.erase("linkfile");
808 }
809 
810 /**
811  * @tc.name: DumpDlpLinkFile001
812  * @tc.desc: test dump link file abnoral branch
813  * @tc.type: FUNC
814  * @tc.require:AR000GVIGC
815  */
816 HWTEST_F(DlpFuseTest, DumpDlpLinkFile001, TestSize.Level1)
817 {
818     DLP_LOG_INFO(LABEL, "DumpDlpLinkFile001");
819     std::shared_ptr<DlpFile> filePtr = std::make_shared<DlpFile>(1000, DLP_TEST_DIR, 0, false);
820     ASSERT_NE(filePtr, nullptr);
821     DlpLinkFile *node = new (std::nothrow) DlpLinkFile("linkfile1", filePtr);
822     ASSERT_NE(node, nullptr);
823     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_["linkfile"] = nullptr;
824     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_["linkfile1"] = node;
825     std::vector<DlpLinkFileInfo> linkList;
826     DlpLinkManager::GetInstance().DumpDlpLinkFile(linkList);
827     EXPECT_NE(static_cast<int>(linkList.size()), 0);
828     if (linkList.size() > 0) {
829         EXPECT_EQ(linkList[0].dlpLinkName, "linkfile1");
830     }
831 
832     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_.erase("linkfile");
833     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_.erase("linkfile1");
834     delete(node);
835 }
836 
837 /**
838  * @tc.name: ReadFuseDir001
839  * @tc.desc: test fuse readdir
840  * @tc.type: FUNC
841  * @tc.require:AR000GVIGC
842  */
843 HWTEST_F(DlpFuseTest, ReadFuseDir001, TestSize.Level1)
844 {
845     DLP_LOG_INFO(LABEL, "ReadFuseDir001");
846     g_plainFileFd = open("/data/fuse_test.txt", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
847     g_dlpFileFd = open("/data/fuse_test.txt.dlp", O_CREAT | O_RDWR | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
848     ASSERT_GE(g_plainFileFd, 0);
849     ASSERT_GE(g_dlpFileFd, 0);
850 
851     char buffer[] = "123456";
852     ASSERT_NE(write(g_plainFileFd, buffer, strlen("123456")), -1);
853 
854     struct DlpProperty prop;
855     GenerateRandProperty(prop);
856 
857     ASSERT_EQ(DlpFileManager::GetInstance().GenerateDlpFile(g_plainFileFd,
858         g_dlpFileFd, prop, g_Dlpfile, DLP_TEST_DIR), 0);
859     ASSERT_NE(g_Dlpfile, nullptr);
860     ASSERT_EQ(DlpLinkManager::GetInstance().AddDlpLinkFile(g_Dlpfile, TEST_LINK_FILE_NAME), 0);
861 
862     DIR *dir = opendir(MOUNT_POINT_DIR.c_str());
863     ASSERT_NE(dir, nullptr);
864 
865     struct dirent *entry = readdir(dir);
866     ASSERT_NE(entry, nullptr); // "."
867     entry = readdir(dir);
868     ASSERT_NE(entry, nullptr); // ".."
869     entry = readdir(dir);
870     ASSERT_NE(entry, nullptr);
871     ASSERT_EQ(strcmp(TEST_LINK_FILE_NAME.c_str(), entry->d_name), 0);
872     closedir(dir);
873     ASSERT_EQ(DlpLinkManager::GetInstance().DeleteDlpLinkFile(g_Dlpfile), 0);
874     ASSERT_EQ(DlpFileManager::GetInstance().CloseDlpFile(g_Dlpfile), 0);
875     g_Dlpfile = nullptr;
876 }
877 
878 /**
879  * @tc.name: DlpLinkFile001
880  * @tc.desc: test DlpLinkFile construction
881  * @tc.type: FUNC
882  * @tc.require:AR000GVIGC
883  */
884 HWTEST_F(DlpFuseTest, DlpLinkFile001, TestSize.Level1)
885 {
886     DLP_LOG_INFO(LABEL, "DlpLinkFile001");
887     std::shared_ptr<DlpFile> filePtr = nullptr;
888     DlpLinkFile linkFile("linkfile", filePtr);
889     ASSERT_EQ(static_cast<int>(linkFile.fileStat_.st_mode), 0);
890 }
891 
892 /**
893  * @tc.name: SubAndCheckZeroRef001
894  * @tc.desc: test link file subtract reference abnormal branch
895  * @tc.type: FUNC
896  * @tc.require:AR000GVIGC
897  */
898 HWTEST_F(DlpFuseTest, SubAndCheckZeroRef001, TestSize.Level1)
899 {
900     DLP_LOG_INFO(LABEL, "SubAndCheckZeroRef001");
901     std::shared_ptr<DlpFile> filePtr = nullptr;
902     DlpLinkFile linkFile("linkfile", filePtr);
903     EXPECT_FALSE(linkFile.SubAndCheckZeroRef(-1));
904     EXPECT_TRUE(linkFile.SubAndCheckZeroRef(5));
905 }
906 
907 /**
908  * @tc.name: IncreaseRef001
909  * @tc.desc: test link file increase reference abnormal branch
910  * @tc.type: FUNC
911  * @tc.require:AR000GVIGC
912  */
913 HWTEST_F(DlpFuseTest, IncreaseRef001, TestSize.Level1)
914 {
915     DLP_LOG_INFO(LABEL, "IncreaseRef001");
916     std::shared_ptr<DlpFile> filePtr = nullptr;
917     DlpLinkFile linkFile("linkfile", filePtr);
918     linkFile.refcount_ = 0;
919     linkFile.IncreaseRef();
920     ASSERT_NE(linkFile.refcount_, 1);
921 }
922 
923 /**
924  * @tc.name: GetLinkStat001
925  * @tc.desc: test get link file state abnormal branch
926  * @tc.type: FUNC
927  * @tc.require:AR000GVIGC
928  */
929 HWTEST_F(DlpFuseTest, GetLinkStat001, TestSize.Level1)
930 {
931     DLP_LOG_INFO(LABEL, "GetLinkStat001");
932     std::shared_ptr<DlpFile> filePtr = nullptr;
933     DlpLinkFile linkFile("linkfile", filePtr);
934     struct stat fs = linkFile.GetLinkStat();
935     ASSERT_EQ(fs.st_size, 0);
936 }
937 
938 /**
939  * @tc.name: LinkFileTruncate001
940  * @tc.desc: test link file truncate abnormal branch
941  * @tc.type: FUNC
942  * @tc.require:AR000GVIGC
943  */
944 HWTEST_F(DlpFuseTest, LinkFileTruncate001, TestSize.Level1)
945 {
946     DLP_LOG_INFO(LABEL, "LinkFileTruncate001");
947     std::shared_ptr<DlpFile> filePtr = nullptr;
948     DlpLinkFile linkFile("linkfile", filePtr);
949 
950     EXPECT_EQ(linkFile.Truncate(-1), DLP_FUSE_ERROR_VALUE_INVALID);
951     EXPECT_EQ(linkFile.Truncate(0xffffffff), DLP_FUSE_ERROR_VALUE_INVALID);
952     EXPECT_EQ(linkFile.Truncate(0), DLP_FUSE_ERROR_DLP_FILE_NULL);
953     filePtr = std::make_shared<DlpFile>(-1, DLP_TEST_DIR, 0, false);
954     ASSERT_NE(filePtr, nullptr);
955 
956     DlpLinkFile linkFile1("linkfile1", filePtr);
957     EXPECT_EQ(linkFile1.Truncate(0), DLP_PARSE_ERROR_FILE_READ_ONLY);
958 }
959 
960 /**
961  * @tc.name: LinkFileWrite001
962  * @tc.desc: test link file write abnormal branch
963  * @tc.type: FUNC
964  * @tc.require:AR000GVIGC
965  */
966 HWTEST_F(DlpFuseTest, LinkFileWrite001, TestSize.Level1)
967 {
968     DLP_LOG_INFO(LABEL, "LinkFileWrite001");
969     std::shared_ptr<DlpFile> filePtr = nullptr;
970     DlpLinkFile linkFile("linkfile", filePtr);
971 
972     uint8_t buffer[16] = {0};
973     EXPECT_EQ(linkFile.Write(0, buffer, 15), DLP_FUSE_ERROR_DLP_FILE_NULL);
974 
975     filePtr = std::make_shared<DlpFile>(-1, DLP_TEST_DIR, 0, false);
976     ASSERT_NE(filePtr, nullptr);
977 
978     DlpLinkFile linkFile1("linkfile1", filePtr);
979     EXPECT_EQ(linkFile1.Write(0, buffer, 15), DLP_PARSE_ERROR_FILE_READ_ONLY);
980 }
981 
982 /**
983  * @tc.name: LinkFileRead001
984  * @tc.desc: test link file read abnormal branch
985  * @tc.type: FUNC
986  * @tc.require:AR000GVIGC
987  */
988 HWTEST_F(DlpFuseTest, LinkFileRead001, TestSize.Level1)
989 {
990     DLP_LOG_INFO(LABEL, "LinkFileRead001");
991     std::shared_ptr<DlpFile> filePtr = nullptr;
992     DlpLinkFile linkFile("linkfile", filePtr);
993     linkFile.hasRead_ = true;
994     uint8_t buffer[16] = {0};
995     EXPECT_EQ(linkFile.Read(0, buffer, 15, 0), DLP_FUSE_ERROR_DLP_FILE_NULL);
996 
997     filePtr = std::make_shared<DlpFile>(-1, DLP_TEST_DIR, 0, false);
998     ASSERT_NE(filePtr, nullptr);
999 
1000     DlpLinkFile linkFile1("linkfile1", filePtr);
1001     EXPECT_EQ(linkFile1.Read(0, buffer, 15, 0), DLP_PARSE_ERROR_VALUE_INVALID);
1002 }
1003 
1004 /**
1005  * @tc.name: Truncate001
1006  * @tc.desc: test dlp link file truncate
1007  * @tc.type: FUNC
1008  * @tc.require:AR000GVIGC
1009  */
1010 HWTEST_F(DlpFuseTest, Truncate001, TestSize.Level1)
1011 {
1012     std::shared_ptr<DlpFile> filePtr = nullptr;
1013     DlpLinkFile linkFile("linkfile", filePtr);
1014     linkFile.stopLinkFlag_ = true;
1015     EXPECT_EQ(linkFile.Truncate(-1), DLP_LINK_FILE_NOT_ALLOW_OPERATE);
1016     uint8_t buffer[16] = {0};
1017     linkFile.hasRead_ = true;
1018     EXPECT_EQ(linkFile.Write(0, buffer, 15), DLP_LINK_FILE_NOT_ALLOW_OPERATE);
1019     EXPECT_EQ(linkFile.Read(0, buffer, 15, 0), DLP_LINK_FILE_NOT_ALLOW_OPERATE);
1020 }
1021 
1022 /**
1023  * @tc.name: StopDlpLinkFile001
1024  * @tc.desc: StopDlpLinkFile
1025  * @tc.type: FUNC
1026  * @tc.require:AR000GVIGC
1027  */
1028 HWTEST_F(DlpFuseTest, StopDlpLinkFile001, TestSize.Level1)
1029 {
1030     std::shared_ptr<DlpFile> filePtr = nullptr;
1031     std::shared_ptr<DlpFile> filePtr2 = nullptr;
1032     EXPECT_EQ(DlpLinkManager::GetInstance().StopDlpLinkFile(filePtr), DLP_FUSE_ERROR_DLP_FILE_NULL);
1033     filePtr = std::make_shared<DlpFile>(1000, DLP_TEST_DIR, 0, false);
1034     filePtr2 = std::make_shared<DlpFile>(1001, DLP_TEST_DIR, 0, false);
1035 
1036     DlpLinkManager::GetInstance().AddDlpLinkFile(filePtr, "linkfile");
1037     EXPECT_EQ(DlpLinkManager::GetInstance().StopDlpLinkFile(filePtr2), DLP_FUSE_ERROR_LINKFILE_NOT_EXIST);
1038     DlpLinkFile* node = new (std::nothrow) DlpLinkFile("linkfile1", filePtr);
1039     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_["linkfile1"] = node;
1040     EXPECT_EQ(DlpLinkManager::GetInstance().StopDlpLinkFile(filePtr), DLP_OK);
1041     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_["linkfile"] = nullptr;
1042     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_["linkfile1"] = nullptr;
1043     EXPECT_EQ(DlpLinkManager::GetInstance().StopDlpLinkFile(filePtr), DLP_FUSE_ERROR_DLP_FILE_NULL);
1044     delete (node);
1045 }
1046 
1047 /**
1048  * @tc.name: RestartDlpLinkFile001
1049  * @tc.desc: RestartDlpLinkFile
1050  * @tc.type: FUNC
1051  * @tc.require:AR000GVIGC
1052  */
1053 HWTEST_F(DlpFuseTest, RestartDlpLinkFile001, TestSize.Level1)
1054 {
1055     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_.clear();
1056     std::shared_ptr<DlpFile> filePtr = nullptr;
1057     EXPECT_EQ(DlpLinkManager::GetInstance().RestartDlpLinkFile(filePtr), DLP_FUSE_ERROR_DLP_FILE_NULL);
1058     filePtr = std::make_shared<DlpFile>(1000, DLP_TEST_DIR, 0, false);
1059     std::shared_ptr<DlpFile> filePtr2 = nullptr;
1060     filePtr2 = std::make_shared<DlpFile>(1001, DLP_TEST_DIR, 0, false);
1061 
1062     DlpLinkManager::GetInstance().AddDlpLinkFile(filePtr, "linkfile");
1063     EXPECT_EQ(DlpLinkManager::GetInstance().RestartDlpLinkFile(filePtr2), DLP_FUSE_ERROR_LINKFILE_NOT_EXIST);
1064     DlpLinkFile* node = new (std::nothrow) DlpLinkFile("linkfile1", filePtr);
1065     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_["linkfile1"] = node;
1066     EXPECT_EQ(DlpLinkManager::GetInstance().RestartDlpLinkFile(filePtr), DLP_OK);
1067     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_["linkfile"] = nullptr;
1068     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_["linkfile1"] = nullptr;
1069     EXPECT_EQ(DlpLinkManager::GetInstance().RestartDlpLinkFile(filePtr), DLP_FUSE_ERROR_DLP_FILE_NULL);
1070     delete (node);
1071 }
1072 
1073 /**
1074  * @tc.name: ReplaceDlpLinkFile001
1075  * @tc.desc: ReplaceDlpLinkFile
1076  * @tc.type: FUNC
1077  * @tc.require:AR000GVIGC
1078  */
1079 HWTEST_F(DlpFuseTest, ReplaceDlpLinkFile001, TestSize.Level1)
1080 {
1081     std::shared_ptr<DlpFile> filePtr = nullptr;
1082     EXPECT_EQ(DlpLinkManager::GetInstance().ReplaceDlpLinkFile(filePtr, "test"), DLP_FUSE_ERROR_DLP_FILE_NULL);
1083     filePtr = std::make_shared<DlpFile>(1000, DLP_TEST_DIR, 0, false);
1084 
1085     DlpLinkManager::GetInstance().AddDlpLinkFile(filePtr, "linkfile");
1086     EXPECT_EQ(DlpLinkManager::GetInstance().ReplaceDlpLinkFile(filePtr, ""), DLP_FUSE_ERROR_VALUE_INVALID);
1087     EXPECT_EQ(DlpLinkManager::GetInstance().ReplaceDlpLinkFile(filePtr, "test"), DLP_FUSE_ERROR_LINKFILE_NOT_EXIST);
1088     DlpLinkFile* node = new (std::nothrow) DlpLinkFile("linkfile1", filePtr);
1089     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_["linkfile1"] = node;
1090     EXPECT_EQ(DlpLinkManager::GetInstance().ReplaceDlpLinkFile(filePtr, "linkfile1"), DLP_OK);
1091     DlpLinkManager::GetInstance().g_DlpLinkFileNameMap_["linkfile"] = nullptr;
1092     EXPECT_EQ(DlpLinkManager::GetInstance().ReplaceDlpLinkFile(filePtr, "linkfile"), DLP_FUSE_ERROR_DLP_FILE_NULL);
1093     delete (node);
1094 }
1095 }  // namespace DlpPermission
1096 }  // namespace Security
1097 }  // namespace OHOS
1098