• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include <gtest/gtest.h>
16 
17 #include "init_param.h"
18 #include "param_message.h"
19 #include "param_stub.h"
20 #include "trigger_manager.h"
21 #include "param_utils.h"
22 #include "param_osadp.h"
23 #include "param_manager.h"
24 
25 using namespace testing::ext;
26 using namespace std;
27 
28 extern "C" {
29 int WorkSpaceNodeCompare(const HashNode *node1, const HashNode *node2);
30 }
31 
OnClose(ParamTaskPtr client)32 static void OnClose(ParamTaskPtr client)
33 {
34     UNUSED(client);
35 }
36 
CheckServerParamValue(const char * name,const char * expectValue)37 static int CheckServerParamValue(const char *name, const char *expectValue)
38 {
39     char tmp[PARAM_BUFFER_SIZE] = {0};
40     u_int32_t len = sizeof(tmp);
41     SystemReadParam(name, tmp, &len);
42     printf("CheckParamValue name %s value: \'%s\' expectValue:\'%s\' \n", name, tmp, expectValue);
43     EXPECT_NE((int)strlen(tmp), 0);
44     if (expectValue != nullptr) {
45         EXPECT_EQ(strcmp(tmp, expectValue), 0);
46     }
47     return 0;
48 }
49 
50 namespace init_ut {
51 class ParamUnitTest : public ::testing::Test {
52 public:
ParamUnitTest()53     ParamUnitTest() {}
~ParamUnitTest()54     virtual ~ParamUnitTest() {}
55 
SetUpTestCase(void)56     static void SetUpTestCase(void)
57     {
58         PrepareInitUnitTestEnv();
59     };
SetUp()60     void SetUp() {}
TearDown()61     void TearDown() {}
TestBody()62     void TestBody() {}
63 
TestSetParams(const char * params[][1+1],int num)64     int TestSetParams(const char *params[][1 + 1], int num)
65     {
66         for (int i = 0; i < num; i++) {
67             SystemWriteParam(params[i][0], params[i][1]);
68         }
69 
70         // check
71         for (int i = 0; i < num; i++) {
72             CheckServerParamValue(params[i][0], params[i][1]);
73         }
74 
75         for (int i = num - 1; i >= 0; i--) {
76             CheckServerParamValue(params[i][0], params[i][1]);
77         }
78         return 0;
79     }
80 
TestAddSecurityLabel1()81     int TestAddSecurityLabel1()
82     {
83         GetParamSecurityLabel()->cred.gid = 9999;  // 9999 test gid
84         const char *name = "label1.test.aaa.bbb.ccc.dddd.eee";
85         const char *value = "2001";
86         uint32_t labelIndex = 0;
87         SystemWriteParam(name, value);
88         // get root
89         WorkSpace *workspace = GetWorkSpace(WORKSPACE_NAME_DAC);
90         (void)FindTrieNode(workspace, name, strlen(name), &labelIndex);
91         ParamSecurityNode *node = (ParamSecurityNode *)GetTrieNode(workspace, labelIndex);
92         if (node == nullptr) {
93             EXPECT_EQ(1, 0);
94             return 0;
95         }
96         EXPECT_EQ(node->gid, DAC_DEFAULT_GROUP);
97         return 0;
98     }
99 
100     // 添加一个label，最长匹配到这个节点
TestAddSecurityLabel2()101     int TestAddSecurityLabel2()
102     {
103         GetParamSecurityLabel()->cred.gid = 9999;  // 9999 test gid
104         const char *name = "label2.test.aaa.bbb.ccc.dddd.eee";
105         const char *value = "2001";
106         ParamAuditData auditData = {};
107         auditData.name = "label2.test.aaa";
108         auditData.dacData.gid = 202;  // 202 test dac gid
109         auditData.dacData.uid = geteuid();
110         auditData.dacData.mode = 0666;  // 0666 test mode
111         SystemWriteParam(name, value);
112         uint32_t labelIndex = 0;
113         AddSecurityLabel(&auditData);
114         WorkSpace *workspace = GetWorkSpace(WORKSPACE_NAME_DAC);
115         (void)FindTrieNode(workspace, name, strlen(name), &labelIndex);
116         ParamSecurityNode *node = (ParamSecurityNode *)GetTrieNode(workspace, labelIndex);
117         if (node == nullptr) {
118             EXPECT_EQ(1, 0);
119             return 0;
120         }
121         EXPECT_EQ(node->gid, auditData.dacData.gid);
122         return 0;
123     }
124 
125     // 添加一个label，最长匹配到最后一个相同节点
TestAddSecurityLabel3()126     int TestAddSecurityLabel3()
127     {
128         GetParamSecurityLabel()->cred.gid = 9999;  // 9999 test gid
129         const char *name = "label3.test.aaa.bbb.ccc.dddd.eee";
130         const char *value = "2001";
131         ParamAuditData auditData = {};
132         auditData.name = "label3.test.aaa";
133         auditData.dacData.gid = 203;  // 203 test gid
134         auditData.dacData.uid = geteuid();
135         auditData.dacData.mode = 0666;  // 0666 test mode
136         SystemWriteParam(name, value);
137         AddSecurityLabel(&auditData);
138 
139         auditData.name = "label3.test.aaa.bbb.ccc.dddd.eee.dddd";
140         auditData.dacData.gid = 202;  // 202 test dac gid
141         auditData.dacData.uid = geteuid();
142         auditData.dacData.mode = 0666;  // 0666 test mode
143         SystemWriteParam(name, value);
144         AddSecurityLabel(&auditData);
145 
146         uint32_t labelIndex = 0;
147         WorkSpace *workspace = GetWorkSpace(WORKSPACE_NAME_DAC);
148         ParamTrieNode *paramNode = FindTrieNode(workspace, name, strlen(name), &labelIndex);
149         ParamSecurityNode *node = (ParamSecurityNode *)GetTrieNode(workspace, labelIndex);
150         if (paramNode == nullptr || node == nullptr) {
151             EXPECT_EQ(1, 0);
152             return 0;
153         }
154         EXPECT_EQ((int)node->gid, 203);  // 203 test gid
155         return 0;
156     }
157 
158     // 添加一个label，完全匹配
TestAddSecurityLabel4()159     int TestAddSecurityLabel4()
160     {
161         GetParamSecurityLabel()->cred.gid = 9999;  // 9999 test gid
162         const char *name = "label4.test.aaa.bbb.ccc.dddd.eee";
163         const char *value = "2001";
164         ParamAuditData auditData = {};
165         auditData.name = "label4.test.aaa.bbb.ccc.dddd.eee";
166         auditData.dacData.gid = 203;  // 203 test gid
167         auditData.dacData.uid = geteuid();
168         auditData.dacData.mode = 0666;  // 0666 test mode
169         SystemWriteParam(name, value);
170         uint32_t labelIndex = 0;
171         AddSecurityLabel(&auditData);
172         WorkSpace *workspace = GetWorkSpace(WORKSPACE_NAME_DAC);
173         ParamTrieNode *paramNode = FindTrieNode(workspace, name, strlen(name), &labelIndex);
174         ParamSecurityNode *node = (ParamSecurityNode *)GetTrieNode(workspace, labelIndex);
175         if (paramNode == nullptr || node == nullptr) {
176             EXPECT_EQ(1, 0);
177             return 0;
178         }
179         EXPECT_EQ(node->gid, auditData.dacData.gid);
180         return 0;
181     }
182 
TestBufferValue(char * buffer,uint32_t len)183     void TestBufferValue(char *buffer, uint32_t len)
184     {
185         const int printBase = 10;
186         for (uint32_t index = 0; index <= len; index++) {
187             buffer[index] = '0' + index % printBase;
188             if (index != 0 && index % printBase == 0) {
189                 buffer[index] = '.';
190             }
191         }
192         buffer[len] = '\0';
193     }
194 
TestNameIsValid()195     int TestNameIsValid()
196     {
197         char buffer[PARAM_BUFFER_SIZE];
198         // set name length = 127
199         TestBufferValue(buffer, PARAM_NAME_LEN_MAX - 1);
200         int ret = SystemWriteParam(buffer, "1111");
201         EXPECT_EQ(ret, 0);
202         TestBufferValue(buffer, PARAM_NAME_LEN_MAX);
203         ret = SystemWriteParam(buffer, "1111");
204         EXPECT_NE(ret, 0);
205         TestBufferValue(buffer, PARAM_NAME_LEN_MAX + 1);
206         ret = SystemWriteParam(buffer, "1111");
207         EXPECT_NE(ret, 0);
208 
209         // 保存一个只读的属性，大于最大值
210         TestBufferValue(buffer, PARAM_VALUE_LEN_MAX - 1);
211         ret = SystemWriteParam("const.test_readonly.dddddddddddddddddd.fffffffffffffffffff", buffer);
212         EXPECT_EQ(ret, 0);
213 
214         TestBufferValue(buffer, PARAM_VALUE_LEN_MAX + 1);
215         ret = SystemWriteParam("const.test_readonly.aaaaaaaaaaaaaaaaaa.fffffffffffffffffff", buffer);
216         EXPECT_EQ(ret, 0);
217 
218         // 更新只读项目
219         TestBufferValue(buffer, PARAM_VALUE_LEN_MAX - 1);
220         ret = SystemWriteParam("const.test_readonly.dddddddddddddddddd.fffffffffffffffffff", buffer);
221         EXPECT_NE(ret, 0);
222 
223         // 写普通属性
224         TestBufferValue(buffer, PARAM_VALUE_LEN_MAX - 1);
225         ret = SystemWriteParam("test.bigvalue.dddddddddddddddddd.fffffffffffffffffff", buffer);
226         EXPECT_EQ(ret, 0);
227         TestBufferValue(buffer, PARAM_VALUE_LEN_MAX + 1);
228         ret = SystemWriteParam("test.bigvalue.dddddddddddddddddd.fffffffffffffffffff", buffer);
229         EXPECT_NE(ret, 0);
230 
231         // invalid name
232         TestBufferValue(buffer, PARAM_VALUE_LEN_MAX - 1);
233         ret = SystemWriteParam("test.invalidname..fffffffffffffffffff", buffer);
234         EXPECT_NE(ret, 0);
235         ret = SystemWriteParam("test.invalidname.%fffffffffffffffffff", buffer);
236         EXPECT_NE(ret, 0);
237         ret = SystemWriteParam("test.invalidname.$fffffffffffffffffff", buffer);
238         EXPECT_NE(ret, 0);
239         return 0;
240     }
241 
TestParamTraversal()242     int TestParamTraversal()
243     {
244         char value[PARAM_BUFFER_SIZE + PARAM_BUFFER_SIZE] = {0};
245         SystemTraversalParameter(
246             "",
247             [](ParamHandle handle, void *cookie) {
248                 SystemGetParameterName(handle, (char *)cookie, PARAM_BUFFER_SIZE);
249                 u_int32_t len = PARAM_BUFFER_SIZE;
250                 SystemGetParameterValue(handle, ((char *)cookie) + PARAM_BUFFER_SIZE, &len);
251                 printf("$$$$$$$$Param %s=%s \n", (char *)cookie, ((char *)cookie) + PARAM_BUFFER_SIZE);
252             },
253             (void *)value);
254         return 0;
255     }
256 
TestUpdateParam(const char * name,const char * value)257     int TestUpdateParam(const char *name, const char *value)
258     {
259         SystemWriteParam(name, value);
260         SystemWriteParam(name, value);
261         SystemWriteParam(name, value);
262         SystemWriteParam(name, value);
263         CheckServerParamValue(name, value);
264         return 0;
265     }
266 
TestPersistParam()267     int TestPersistParam()
268     {
269         ParamAuditData auditData = {};
270         auditData.name = "persist.";
271         auditData.dacData.gid = 0;
272         auditData.dacData.uid = 0;
273         auditData.dacData.mode = 0777;  // 0777 test mode
274         AddSecurityLabel(&auditData);
275 
276         LoadPersistParams();
277         SystemWriteParam("persist.111.ffff.bbbb.cccc.dddd.eeee", "1101");
278         SystemWriteParam("persist.111.aaaa.bbbb.cccc.dddd.eeee", "1102");
279         SystemWriteParam("persist.111.bbbb.cccc.dddd.eeee", "1103");
280         CheckServerParamValue("persist.111.bbbb.cccc.dddd.eeee", "1103");
281 
282         SystemWriteParam("persist.111.cccc.bbbb.cccc.dddd.eeee", "1104");
283         SystemWriteParam("persist.111.eeee.bbbb.cccc.dddd.eeee", "1105");
284         CheckServerParamValue("persist.111.ffff.bbbb.cccc.dddd.eeee", "1101");
285         SystemWriteParam("persist.111.ffff.bbbb.cccc.dddd.eeee", "1106");
286         CheckServerParamValue("persist.111.ffff.bbbb.cccc.dddd.eeee", "1106");
287         sleep(1);
288         SystemWriteParam("persist.111.bbbb.cccc.dddd.1107", "1107");
289         SystemWriteParam("persist.111.bbbb.cccc.dddd.1108", "1108");
290         SystemWriteParam("persist.111.bbbb.cccc.dddd.1109", "1108");
291         sleep(1);
292         SystemWriteParam("persist.111.bbbb.cccc.dddd.1110", "1108");
293         SystemWriteParam("persist.111.bbbb.cccc.dddd.1111", "1108");
294         TimerCallbackForSave(nullptr, nullptr);
295         LoadPersistParams();
296         return 0;
297     }
298 
TestDumpParamMemory()299     int TestDumpParamMemory()
300     {
301         SystemDumpParameters(1, NULL);
302         return 0;
303     }
304 };
305 
306 HWTEST_F(ParamUnitTest, TestPersistParam, TestSize.Level0)
307 {
308     ParamUnitTest test;
309     test.TestPersistParam();
310 }
311 
312 HWTEST_F(ParamUnitTest, TestSetParam_1, TestSize.Level0)
313 {
314     ParamUnitTest test;
315     const char *params[][2] = {{"111.2222", "1"},
316                                {"111.2222.3333", "2"},
317                                {"111.2222.3333.4444", "3"},
318                                {"111.2222.3333.4444.666", "4"},
319                                {"111.2222.3333.4444.666.777", "5"}};
320     test.TestSetParams(params, 5);
321 }
322 
323 HWTEST_F(ParamUnitTest, TestSetParam_2, TestSize.Level0)
324 {
325     ParamUnitTest test;
326     const char *params[][2] = {{"111.2222.xxxx.xxx.xxx", "1_1"},
327                                {"111.2222.3333.xxx", "1_2"},
328                                {"111.2222.xxxx.3333.4444", "1_3"},
329                                {"111.2222.3333.xxxx.4444.666", "1_4"},
330                                {"111.2222.3333.4444.666.xxxxx.777", "1_5"}};
331     test.TestSetParams(params, 5);
332 
333     const char *ctrlParams[][2] = {{"ctl.start.111.2222.xxxx.xxx.xxx", "2_1"},
334                                    {"ctl.start.111.2222.3333.xxx", "2_2"},
335                                    {"ctl.start.111.2222.xxxx.3333.4444", "2_3"},
336                                    {"ctl.start.111.2222.3333.xxxx.4444.666", "2_4"},
337                                    {"ctl.start.111.2222.3333.4444.666.xxxxx.777", "2_5"}};
338     test.TestSetParams(ctrlParams, 5);
339 
340     const char *sysParams[][2] = {{"ohos.startup.powerctrl.111.2222.xxxx.xxx.xxx", "3_1"},
341                                   {"ohos.startup.powerctrl.111.2222.3333.xxx", "3_2"},
342                                   {"ohos.startup.powerctrl.111.2222.xxxx.3333.4444", "3_3"},
343                                   {"ohos.startup.powerctrl.111.2222.3333.xxxx.4444.666", "3_4"},
344                                   {"ohos.startup.powerctrl.111.2222.3333.4444.666.xxxxx.777", "3_5"}};
345     test.TestSetParams(sysParams, 5);
346 }
347 
348 HWTEST_F(ParamUnitTest, TestNameIsValid, TestSize.Level0)
349 {
350     ParamUnitTest test;
351     test.TestNameIsValid();
352 }
353 
354 HWTEST_F(ParamUnitTest, TestAddSecurityLabel1, TestSize.Level0)
355 {
356     ParamUnitTest test;
357     test.TestAddSecurityLabel1();
358 }
359 
360 HWTEST_F(ParamUnitTest, TestAddSecurityLabel2, TestSize.Level0)
361 {
362     ParamUnitTest test;
363     test.TestAddSecurityLabel2();
364 }
365 
366 HWTEST_F(ParamUnitTest, TestAddSecurityLabel3, TestSize.Level0)
367 {
368     ParamUnitTest test;
369     test.TestAddSecurityLabel3();
370 }
371 
372 HWTEST_F(ParamUnitTest, TestAddSecurityLabel4, TestSize.Level0)
373 {
374     ParamUnitTest test;
375     test.TestAddSecurityLabel4();
376 }
377 
378 HWTEST_F(ParamUnitTest, TestUpdateParam, TestSize.Level0)
379 {
380     ParamUnitTest test;
381     test.TestUpdateParam("test.aaa.bbb.ccc.ddd", "100");
382     test.TestUpdateParam("test.aaa.bbb.ccc.ddd", "101");
383     test.TestUpdateParam("test.aaa.bbb.ccc.ddd", "102");
384     test.TestUpdateParam("test.aaa.bbb.ccc.ddd", "103");
385     test.TestUpdateParam("net.tcp.default_init_rwnd", "60");
386 }
387 
388 HWTEST_F(ParamUnitTest, TestParamTraversal, TestSize.Level0)
389 {
390     ParamUnitTest test;
391     test.TestParamTraversal();
392 }
393 
394 HWTEST_F(ParamUnitTest, TestDumpParamMemory, TestSize.Level0)
395 {
396     ParamUnitTest test;
397     test.TestDumpParamMemory();
398 }
399 HWTEST_F(ParamUnitTest, TestLinuxRWLock, TestSize.Level0)
400 {
401     ParamRWMutexCreate(nullptr);
402     ParamRWMutexWRLock(nullptr);
403     ParamRWMutexRDLock(nullptr);
404     ParamRWMutexUnlock(nullptr);
405     ParamRWMutexDelete(nullptr);
406     ParamMutexDelete(nullptr);
407     WorkSpace *workspace1 = (WorkSpace *)malloc(sizeof(WorkSpace) + strlen("testfilename1"));
408     ASSERT_NE(nullptr, workspace1);
409     WorkSpace *workspace2 = (WorkSpace *)malloc(sizeof(WorkSpace) + strlen("testfilename1"));
410     ASSERT_NE(nullptr, workspace2);
411     if (strcpy_s(workspace1->fileName, strlen("testfilename1"), "testfilename") != EOK) {
412         EXPECT_EQ(0, 1);
413     }
414     if (strcpy_s(workspace2->fileName, strlen("testfilename1"), "testfilename") != EOK) {
415         EXPECT_EQ(0, 1);
416     }
417     EXPECT_EQ(WorkSpaceNodeCompare(&(workspace1->hashNode), &(workspace2->hashNode)), 0);
418     free(workspace1);
419     free(workspace2);
420 }
421 
422 HWTEST_F(ParamUnitTest, TestGetServiceCtlName, TestSize.Level0)
423 {
424     ServiceCtrlInfo *serviceInfo = NULL;
425     GetServiceCtrlInfo("ohos.startup.powerctrl", "reboot,updater", &serviceInfo);
426     if (serviceInfo != NULL) {
427         EXPECT_STREQ(serviceInfo->realKey, "ohos.servicectrl.reboot.updater.reboot,updater");
428         free(serviceInfo);
429     }
430     GetServiceCtrlInfo("ohos.ctl.stop", "test", &serviceInfo);
431     if (serviceInfo != NULL) {
432         EXPECT_STREQ(serviceInfo->realKey, "ohos.servicectrl.stop.test");
433         free(serviceInfo);
434     }
435     GetServiceCtrlInfo("ohos.servicectrl.stop", "test", &serviceInfo);
436     if (serviceInfo != NULL) {
437         EXPECT_STREQ(serviceInfo->realKey, "ohos.servicectrl.stop.test");
438         free(serviceInfo);
439     }
440 }
441 
442 HWTEST_F(ParamUnitTest, TestParamCache, TestSize.Level0)
443 {
444     const char *name = "test.write.1111111.222222";
445     CachedHandle cacheHandle = CachedParameterCreate(name, "true");
446     EXPECT_NE(cacheHandle, nullptr);
447     const char *value = CachedParameterGet(cacheHandle);
448     EXPECT_EQ(strcmp(value, "true"), 0);
449     uint32_t dataIndex = 0;
450     int ret = WriteParam(name, "false", &dataIndex, 0);
451     EXPECT_EQ(ret, 0);
452     value = CachedParameterGet(cacheHandle);
453     EXPECT_EQ(strcmp(value, "false"), 0);
454     CachedParameterDestroy(cacheHandle);
455 
456     // cache 2, for parameter exist
457     CachedHandle cacheHandle3 = CachedParameterCreate(name, "true");
458     EXPECT_NE(cacheHandle3, nullptr);
459     value = CachedParameterGet(cacheHandle3);
460     EXPECT_EQ(strcmp(value, "false"), 0);
461     ret = WriteParam(name, "2222222", &dataIndex, 0);
462     EXPECT_EQ(ret, 0);
463     value = CachedParameterGet(cacheHandle3);
464     EXPECT_EQ(strcmp(value, "2222222"), 0);
465     CachedParameterDestroy(cacheHandle3);
466 }
467 }