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