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