1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "param_manager.h"
17
18 #include <ctype.h>
19 #include <inttypes.h>
20 #include <limits.h>
21
22 #include "init_cmds.h"
23 #include "init_hook.h"
24 #include "param_base.h"
25 #include "param_trie.h"
26 #include "param_utils.h"
27 #include "securec.h"
28 static DUMP_PRINTF g_printf = printf;
29
30 static int ReadParamName(ParamHandle handle, char *name, uint32_t length);
31
SystemCheckMatchParamWait(const char * name,const char * value)32 ParamNode *SystemCheckMatchParamWait(const char *name, const char *value)
33 {
34 ParamWorkSpace *paramSpace = GetParamWorkSpace();
35 PARAM_CHECK(paramSpace != NULL, return NULL, "Invalid paramSpace");
36 PARAM_WORKSPACE_CHECK(paramSpace, return NULL, "Invalid space");
37
38 WorkSpace *workspace = GetWorkSpaceByName(name);
39 PARAM_CHECK(workspace != NULL, return NULL, "Failed to get workspace %s", name);
40 PARAM_LOGV("SystemCheckMatchParamWait name %s", name);
41 uint32_t nameLength = strlen(name);
42 ParamTrieNode *node = FindTrieNode(workspace, name, nameLength, NULL);
43 if (node == NULL || node->dataIndex == 0) {
44 return NULL;
45 }
46 ParamNode *param = (ParamNode *)GetTrieNode(workspace, node->dataIndex);
47 if (param == NULL) {
48 return NULL;
49 }
50 if ((param->keyLength != nameLength) || (strncmp(param->data, name, nameLength) != 0)) { // compare name
51 return NULL;
52 }
53 ATOMIC_SYNC_OR_AND_FETCH(¶m->commitId, PARAM_FLAGS_WAITED, MEMORY_ORDER_RELEASE);
54 if ((strncmp(value, "*", 1) == 0) || (strcmp(param->data + nameLength + 1, value) == 0)) { // compare value
55 return param;
56 }
57 char *tmp = strstr(value, "*");
58 if (tmp != NULL && (strncmp(param->data + nameLength + 1, value, tmp - value) == 0)) {
59 return param;
60 }
61 return NULL;
62 }
63
ProcessParamTraversal(const WorkSpace * workSpace,const ParamTrieNode * node,const void * cookie)64 static int ProcessParamTraversal(const WorkSpace *workSpace, const ParamTrieNode *node, const void *cookie)
65 {
66 ParamTraversalContext *context = (ParamTraversalContext *)cookie;
67 ParamTrieNode *current = (ParamTrieNode *)node;
68 if (current == NULL) {
69 return 0;
70 }
71 if (current->dataIndex == 0) {
72 return 0;
73 }
74 ParamNode *entry = (ParamNode *)GetTrieNode(workSpace, current->dataIndex);
75 if (entry == NULL) {
76 return 0;
77 }
78 if ((strcmp("#", context->prefix) != 0) && (strncmp(entry->data, context->prefix, strlen(context->prefix)) != 0)) {
79 return 0;
80 }
81 uint32_t index = PARAM_HANDLE(workSpace, current->dataIndex);
82 context->traversalParamPtr(index, context->context);
83 return 0;
84 }
85
SystemTraversalParameter(const char * prefix,TraversalParamPtr traversalParameter,void * cookie)86 int SystemTraversalParameter(const char *prefix, TraversalParamPtr traversalParameter, void *cookie)
87 {
88 ParamWorkSpace *paramSpace = GetParamWorkSpace();
89 PARAM_CHECK(paramSpace != NULL, return -1, "Invalid paramSpace");
90 PARAM_WORKSPACE_CHECK(paramSpace, return -1, "Invalid space");
91 PARAM_CHECK(traversalParameter != NULL, return -1, "The param is null");
92
93 #ifdef PARAM_SUPPORT_SELINUX // load security label
94 ParamSecurityOps *ops = GetParamSecurityOps(PARAM_SECURITY_SELINUX);
95 if (ops != NULL && ops->securityGetLabel != NULL) {
96 ops->securityGetLabel("open");
97 }
98 #endif
99 ParamTraversalContext context = {traversalParameter, cookie, "#"};
100 if (!(prefix == NULL || strlen(prefix) == 0)) {
101 int ret = CheckParamPermission(GetParamSecurityLabel(), prefix, DAC_READ);
102 PARAM_CHECK(ret == 0, return ret, "Forbid to traversal parameters %s", prefix);
103 context.prefix = (char *)prefix;
104 }
105
106 WorkSpace *workSpace = GetNextWorkSpace(NULL);
107 if (workSpace != NULL && strcmp(workSpace->fileName, WORKSPACE_NAME_DAC) == 0) {
108 workSpace = GetNextWorkSpace(workSpace);
109 }
110 while (workSpace != NULL) {
111 WorkSpace *next = GetNextWorkSpace(workSpace);
112 ParamTrieNode *root = NULL;
113 if (prefix != NULL && strlen(prefix) != 0) {
114 root = FindTrieNode(workSpace, prefix, strlen(prefix), NULL);
115 }
116 PARAMSPACE_AREA_RD_LOCK(workSpace);
117 TraversalTrieNode(workSpace, root, ProcessParamTraversal, (const void *)&context);
118 PARAMSPACE_AREA_RW_UNLOCK(workSpace);
119 workSpace = next;
120 }
121 return 0;
122 }
123
DumpTrieDataNodeTraversal(const WorkSpace * workSpace,const ParamTrieNode * node,const void * cookie)124 static int DumpTrieDataNodeTraversal(const WorkSpace *workSpace, const ParamTrieNode *node, const void *cookie)
125 {
126 int verbose = *(int *)cookie;
127 ParamTrieNode *current = (ParamTrieNode *)node;
128 if (current == NULL) {
129 return 0;
130 }
131 if (verbose) {
132 PARAM_DUMP("\tTrie node info [%u,%u,%u] data: %u label: %u key length:%u \n\t key: %s \n",
133 current->left, current->right, current->child,
134 current->dataIndex, current->labelIndex, current->length, current->key);
135 }
136 if (current->dataIndex != 0) {
137 ParamNode *entry = (ParamNode *)GetTrieNode(workSpace, current->dataIndex);
138 if (entry != NULL) {
139 PARAM_DUMP("\tparameter length info [%d] [%u, %u] \n\t param: %s \n",
140 entry->commitId, entry->keyLength, entry->valueLength, entry->data);
141 }
142 }
143 if (current->labelIndex == 0) {
144 return 0;
145 }
146 ParamSecurityNode *label = (ParamSecurityNode *)GetTrieNode(workSpace, current->labelIndex);
147 if (label == NULL) {
148 return 0;
149 }
150 PARAM_DUMP("\tparameter label dac %u %u 0%o \n", label->uid, label->gid, label->mode);
151 PARAM_DUMP("\tparameter label dac member [%u] ", label->memberNum);
152 for (uint32_t i = 0; i < label->memberNum; i++) {
153 PARAM_DUMP(" %u", label->members[i]);
154 }
155 if (label->memberNum > 0) {
156 PARAM_DUMP("\n");
157 }
158 return 0;
159 }
160
HashNodeTraverseForDump(WorkSpace * workSpace,int verbose)161 static void HashNodeTraverseForDump(WorkSpace *workSpace, int verbose)
162 {
163 PARAM_DUMP(" map file: %s \n", workSpace->fileName);
164 PARAM_DUMP(" space index : %d \n", workSpace->spaceIndex);
165 PARAM_DUMP(" space size : %d \n", workSpace->spaceSize);
166 if (workSpace->area != NULL) {
167 PARAM_DUMP(" total size: %u \n", workSpace->area->dataSize);
168 PARAM_DUMP(" first offset: %u \n", workSpace->area->firstNode);
169 PARAM_DUMP(" current offset: %u \n", workSpace->area->currOffset);
170 PARAM_DUMP(" total node: %u \n", workSpace->area->trieNodeCount);
171 PARAM_DUMP(" total param node: %u \n", workSpace->area->paramNodeCount);
172 PARAM_DUMP(" total security node: %u\n", workSpace->area->securityNodeCount);
173 if (verbose) {
174 PARAM_DUMP(" commitId : %" PRId64 "\n", workSpace->area->commitId);
175 PARAM_DUMP(" commitPersistId : %" PRId64 "\n", workSpace->area->commitPersistId);
176 }
177 }
178 PARAM_DUMP(" node info: \n");
179 PARAMSPACE_AREA_RD_LOCK(workSpace);
180 TraversalTrieNode(workSpace, NULL, DumpTrieDataNodeTraversal, (const void *)&verbose);
181 PARAMSPACE_AREA_RW_UNLOCK(workSpace);
182 }
183
SystemDumpParameters(int verbose,int index,int (* dump)(const char * fmt,...))184 void SystemDumpParameters(int verbose, int index, int (*dump)(const char *fmt, ...))
185 {
186 if (dump != NULL) {
187 g_printf = dump;
188 } else {
189 g_printf = printf;
190 }
191 ParamWorkSpace *paramSpace = GetParamWorkSpace();
192 PARAM_CHECK(paramSpace != NULL, return, "Invalid paramSpace");
193 PARAM_WORKSPACE_CHECK(paramSpace, return, "Invalid space");
194 // check default dac
195 int ret = CheckParamPermission(GetParamSecurityLabel(), "#", DAC_READ);
196 PARAM_CHECK(ret == 0, return, "Forbid to dump parameters ");
197 #ifdef PARAM_SUPPORT_SELINUX // load security label
198 ParamSecurityOps *ops = GetParamSecurityOps(PARAM_SECURITY_SELINUX);
199 if (ops != NULL && ops->securityGetLabel != NULL) {
200 ops->securityGetLabel("open");
201 }
202 #endif
203 PARAM_DUMP("Dump all parameters begin ...\n");
204 if (verbose) {
205 PARAM_DUMP("Local security information\n");
206 PARAM_DUMP("pid: %d uid: %u gid: %u \n",
207 paramSpace->securityLabel.cred.pid,
208 paramSpace->securityLabel.cred.uid,
209 paramSpace->securityLabel.cred.gid);
210 }
211 if (index > 0) {
212 WorkSpace *workSpace = GetWorkSpace(index);
213 if (workSpace != NULL) {
214 HashNodeTraverseForDump(workSpace, verbose);
215 }
216 return;
217 }
218 // show workspace size
219 WorkSpaceSize *spaceSize = GetWorkSpaceSize(GetWorkSpace(WORKSPACE_INDEX_SIZE));
220 if (spaceSize != NULL) {
221 PARAM_DUMP("Max label index : %u\n", spaceSize->maxLabelIndex);
222 for (uint32_t i = 0; i < spaceSize->maxLabelIndex; i++) {
223 if (spaceSize->spaceSize[i] == PARAM_WORKSPACE_MIN) {
224 continue;
225 }
226 PARAM_DUMP("\t workspace %u size : %u\n", i, spaceSize->spaceSize[i]);
227 }
228 }
229
230 WorkSpace *workSpace = GetNextWorkSpace(NULL);
231 while (workSpace != NULL) {
232 WorkSpace *next = GetNextWorkSpace(workSpace);
233 HashNodeTraverseForDump(workSpace, verbose);
234 workSpace = next;
235 }
236 PARAM_DUMP("Dump all parameters finish\n");
237 }
238
SysCheckParamExist(const char * name)239 INIT_LOCAL_API int SysCheckParamExist(const char *name)
240 {
241 ParamWorkSpace *paramSpace = GetParamWorkSpace();
242 PARAM_CHECK(paramSpace != NULL, return -1, "Invalid paramSpace");
243 PARAM_WORKSPACE_CHECK(paramSpace, return -1, "Invalid space");
244 PARAM_CHECK(name != NULL, return -1, "The name or handle is null");
245
246 #ifdef PARAM_SUPPORT_SELINUX // load security label
247 ParamSecurityOps *ops = GetParamSecurityOps(PARAM_SECURITY_SELINUX);
248 if (ops != NULL && ops->securityGetLabel != NULL) {
249 ops->securityGetLabel("open");
250 }
251 #endif
252 WorkSpace *workSpace = GetNextWorkSpace(NULL);
253 while (workSpace != NULL) {
254 PARAM_LOGV("SysCheckParamExist name %s in space %s", name, workSpace->fileName);
255 WorkSpace *next = GetNextWorkSpace(workSpace);
256 ParamTrieNode *node = FindTrieNode(workSpace, name, strlen(name), NULL);
257 if (node != NULL && node->dataIndex != 0) {
258 return 0;
259 } else if (node != NULL) {
260 return PARAM_CODE_NODE_EXIST;
261 }
262 workSpace = next;
263 }
264 return PARAM_CODE_NOT_FOUND;
265 }
266
GetParamSecurityAuditData(const char * name,int type,ParamAuditData * auditData)267 INIT_INNER_API int GetParamSecurityAuditData(const char *name, int type, ParamAuditData *auditData)
268 {
269 UNUSED(type);
270 ParamWorkSpace *paramSpace = GetParamWorkSpace();
271 PARAM_CHECK(paramSpace != NULL, return -1, "Invalid paramSpace");
272 PARAM_WORKSPACE_CHECK(paramSpace, return -1, "Invalid space");
273 uint32_t labelIndex = 0;
274 // get from dac
275 WorkSpace *space = GetWorkSpace(WORKSPACE_INDEX_DAC);
276 PARAM_CHECK(space != NULL, return -1, "Invalid workSpace");
277 FindTrieNode(space, name, strlen(name), &labelIndex);
278 ParamSecurityNode *node = (ParamSecurityNode *)GetTrieNode(space, labelIndex);
279 PARAM_CHECK(node != NULL, return DAC_RESULT_FORBIDED, "Can not get security label %d", labelIndex);
280
281 auditData->name = name;
282 auditData->dacData.uid = node->uid;
283 auditData->dacData.gid = node->gid;
284 auditData->dacData.mode = node->mode;
285 #ifdef PARAM_SUPPORT_SELINUX
286 const char *tmpName = (paramSpace->selinuxSpace.getParamLabel != NULL) ?
287 paramSpace->selinuxSpace.getParamLabel(name) : NULL;
288 if (tmpName != NULL) {
289 int ret = strcpy_s(auditData->label, sizeof(auditData->label), tmpName);
290 PARAM_CHECK(ret == 0, return 0, "Failed to copy label for %s", name);
291 }
292 #endif
293 return 0;
294 }
295
CreateCtrlInfo(ServiceCtrlInfo ** ctrlInfo,const char * cmd,uint32_t offset,uint8_t ctrlParam,const char * format,...)296 static int CreateCtrlInfo(ServiceCtrlInfo **ctrlInfo, const char *cmd, uint32_t offset,
297 uint8_t ctrlParam, const char *format, ...)
298 {
299 *ctrlInfo = calloc(1, sizeof(ServiceCtrlInfo));
300 PARAM_CHECK(*ctrlInfo != NULL, return -1, "Failed to alloc memory %s", cmd);
301 va_list vargs;
302 va_start(vargs, format);
303 int len = vsnprintf_s((*ctrlInfo)->realKey,
304 sizeof((*ctrlInfo)->realKey), sizeof((*ctrlInfo)->realKey) - 1, format, vargs);
305 va_end(vargs);
306 int ret = strcpy_s((*ctrlInfo)->cmdName, sizeof((*ctrlInfo)->cmdName), cmd);
307 (*ctrlInfo)->valueOffset = offset;
308 if (ret != 0 || len <= 0) {
309 free(*ctrlInfo);
310 *ctrlInfo = NULL;
311 return -1;
312 }
313 (*ctrlInfo)->ctrlParam = ctrlParam;
314 return 0;
315 }
316
GetServiceCtrlInfoForPowerCtrl(const char * name,const char * value,ServiceCtrlInfo ** ctrlInfo)317 static int GetServiceCtrlInfoForPowerCtrl(const char *name, const char *value, ServiceCtrlInfo **ctrlInfo)
318 {
319 size_t size = 0;
320 const ParamCmdInfo *powerCtrlArg = GetStartupPowerCtl(&size);
321 PARAM_CHECK(powerCtrlArg != NULL, return -1, "Invalid ctrlInfo for %s", name);
322 uint32_t valueOffset = strlen(OHOS_SERVICE_CTRL_PREFIX) + strlen("reboot") + 1;
323 if (strcmp(value, "reboot") == 0) {
324 return CreateCtrlInfo(ctrlInfo, "reboot", valueOffset, 1,
325 "%s%s.%s", OHOS_SERVICE_CTRL_PREFIX, "reboot", value);
326 }
327 for (size_t i = 0; i < size; i++) {
328 PARAM_LOGV("Get power ctrl %s name %s value %s", powerCtrlArg[i].name, name, value);
329 if (strncmp(value, powerCtrlArg[i].name, strlen(powerCtrlArg[i].name)) == 0) {
330 valueOffset = strlen(OHOS_SERVICE_CTRL_PREFIX) + strlen(powerCtrlArg[i].replace) + 1;
331 return CreateCtrlInfo(ctrlInfo, powerCtrlArg[i].cmd, valueOffset, 1,
332 "%s%s.%s", OHOS_SERVICE_CTRL_PREFIX, powerCtrlArg[i].replace, value);
333 }
334 }
335 // not found reboot, so reboot by normal
336 valueOffset = strlen(OHOS_SERVICE_CTRL_PREFIX) + strlen("reboot") + 1;
337 return CreateCtrlInfo(ctrlInfo, "reboot.other", valueOffset, 1, "%s%s.%s",
338 OHOS_SERVICE_CTRL_PREFIX, "reboot", value);
339 }
340
GetServiceCtrlInfo(const char * name,const char * value,ServiceCtrlInfo ** ctrlInfo)341 INIT_LOCAL_API int GetServiceCtrlInfo(const char *name, const char *value, ServiceCtrlInfo **ctrlInfo)
342 {
343 PARAM_CHECK(ctrlInfo != NULL, return -1, "Invalid ctrlInfo %s", name);
344 *ctrlInfo = NULL;
345 size_t size = 0;
346 if (strcmp("ohos.startup.powerctrl", name) == 0) {
347 return GetServiceCtrlInfoForPowerCtrl(name, value, ctrlInfo);
348 }
349 if (strncmp("ohos.ctl.", name, strlen("ohos.ctl.")) == 0) {
350 const ParamCmdInfo *ctrlParam = GetServiceStartCtrl(&size);
351 PARAM_CHECK(ctrlParam != NULL, return -1, "Invalid ctrlInfo for %s", name);
352 for (size_t i = 0; i < size; i++) {
353 if (strcmp(name, ctrlParam[i].name) == 0) {
354 uint32_t valueOffset = strlen(OHOS_SERVICE_CTRL_PREFIX) + strlen(ctrlParam[i].replace) + 1;
355 return CreateCtrlInfo(ctrlInfo, ctrlParam[i].cmd, valueOffset, 1,
356 "%s%s.%s", OHOS_SERVICE_CTRL_PREFIX, ctrlParam[i].replace, value);
357 }
358 }
359 }
360 if (strncmp("ohos.servicectrl.", name, strlen("ohos.servicectrl.")) == 0) {
361 const ParamCmdInfo *installParam = GetServiceCtl(&size);
362 PARAM_CHECK(installParam != NULL, return -1, "Invalid ctrlInfo for %s", name);
363 for (size_t i = 0; i < size; i++) {
364 if (strncmp(name, installParam[i].name, strlen(installParam[i].name)) == 0) {
365 return CreateCtrlInfo(ctrlInfo, installParam[i].cmd, strlen(name) + 1, 1, "%s.%s", name, value);
366 }
367 }
368 }
369 const ParamCmdInfo *other = GetOtherSpecial(&size);
370 for (size_t i = 0; i < size; i++) {
371 if (strncmp(name, other[i].name, strlen(other[i].name)) == 0) {
372 return CreateCtrlInfo(ctrlInfo, other[i].cmd, strlen(other[i].replace), 0, "%s.%s", name, value);
373 }
374 }
375 return 0;
376 }
377
CheckParameterSet(const char * name,const char * value,const ParamSecurityLabel * srcLabel,int * ctrlService)378 INIT_LOCAL_API int CheckParameterSet(const char *name,
379 const char *value, const ParamSecurityLabel *srcLabel, int *ctrlService)
380 {
381 ParamWorkSpace *paramSpace = GetParamWorkSpace();
382 PARAM_CHECK(paramSpace != NULL, return PARAM_WORKSPACE_NOT_INIT, "Invalid paramSpace");
383 PARAM_WORKSPACE_CHECK(paramSpace, return PARAM_WORKSPACE_NOT_INIT, "Invalid space");
384 PARAM_LOGV("CheckParameterSet name %s value: %s", name, value);
385 PARAM_CHECK(srcLabel != NULL && ctrlService != NULL, return -1, "Invalid param ");
386 int ret = CheckParamName(name, 0);
387 PARAM_CHECK(ret == 0, return ret, "Illegal param name %s", name);
388 ret = CheckParamValue(NULL, name, value, GetParamValueType(name));
389 PARAM_CHECK(ret == 0, return ret, "Illegal param value %s", value);
390 *ctrlService = 0;
391
392 ServiceCtrlInfo *serviceInfo = NULL;
393 GetServiceCtrlInfo(name, value, &serviceInfo);
394 ret = CheckParamPermission(srcLabel, (serviceInfo == NULL) ? name : serviceInfo->realKey, DAC_WRITE);
395 if (ret == 0) {
396 if (serviceInfo == NULL) {
397 return 0;
398 }
399 if (serviceInfo->ctrlParam != 0) { // ctrl param
400 *ctrlService |= PARAM_CTRL_SERVICE;
401 }
402 #if !(defined __LITEOS_A__ || defined __LITEOS_M__)
403 // do hook cmd
404 PARAM_LOGV("Check parameter settings realKey %s cmd: '%s' value: %s",
405 serviceInfo->realKey, serviceInfo->cmdName, (char *)serviceInfo->realKey + serviceInfo->valueOffset);
406 int cmdIndex = 0;
407 (void)GetMatchCmd(serviceInfo->cmdName, &cmdIndex);
408 DoCmdByIndex(cmdIndex, (char *)serviceInfo->realKey + serviceInfo->valueOffset, NULL);
409 #endif
410 }
411 if (serviceInfo != NULL) {
412 free(serviceInfo);
413 }
414 return ret;
415 }
416
SystemGetParameterName(ParamHandle handle,char * name,unsigned int len)417 int SystemGetParameterName(ParamHandle handle, char *name, unsigned int len)
418 {
419 PARAM_CHECK(name != NULL && handle != 0, return -1, "The name is null");
420 return ReadParamName(handle, name, len);
421 }
422
AddParam(WorkSpace * workSpace,uint8_t type,const char * name,const char * value,uint32_t * dataIndex,int mode)423 static int AddParam(WorkSpace *workSpace, uint8_t type, const char *name, const char *value, uint32_t *dataIndex, int mode)
424 {
425 ParamTrieNode *node = AddTrieNode(workSpace, name, strlen(name));
426 PARAM_CHECK(node != NULL, return PARAM_CODE_REACHED_MAX,
427 "Failed to add node name %s space %s", name, workSpace->fileName);
428 ParamNode *entry = (ParamNode *)GetTrieNode(workSpace, node->dataIndex);
429 if (entry == NULL) {
430 uint32_t offset = AddParamNode(workSpace, type, name, strlen(name), value, strlen(value), mode);
431 PARAM_CHECK(offset > 0, return PARAM_CODE_REACHED_MAX,
432 "Failed to allocate name %s space %s", name, workSpace->fileName);
433 SaveIndex(&node->dataIndex, offset);
434 ATOMIC_SYNC_ADD_AND_FETCH(&workSpace->area->commitId, 1, MEMORY_ORDER_RELEASE);
435 #ifdef PARAM_SUPPORT_SELINUX
436 WorkSpace *space = GetWorkSpace(WORKSPACE_INDEX_DAC);
437 if (space != NULL && space != workSpace) { // dac commit is global commit
438 ATOMIC_SYNC_ADD_AND_FETCH(&space->area->commitId, 1, MEMORY_ORDER_RELEASE);
439 }
440 #endif
441 }
442 if (dataIndex != NULL) {
443 *dataIndex = node->dataIndex;
444 }
445 PARAM_LOGV("AddParam name %s value: %s", name, value);
446 return 0;
447 }
448
UpdateParam(const WorkSpace * workSpace,uint32_t * dataIndex,const char * name,const char * value,int mode)449 static int UpdateParam(const WorkSpace *workSpace, uint32_t *dataIndex, const char *name, const char *value, int mode)
450 {
451 ParamNode *entry = (ParamNode *)GetTrieNode(workSpace, *dataIndex);
452 PARAM_CHECK(entry != NULL, return PARAM_CODE_REACHED_MAX, "Failed to update param value %s %u", name, *dataIndex);
453 PARAM_CHECK(entry->keyLength == strlen(name), return PARAM_CODE_INVALID_NAME, "Failed to check name len %s", name);
454
455 uint32_t valueLen = strlen(value);
456 uint32_t commitId = ATOMIC_LOAD_EXPLICIT(&entry->commitId, MEMORY_ORDER_RELAXED);
457 ATOMIC_STORE_EXPLICIT(&entry->commitId, commitId | PARAM_FLAGS_MODIFY, MEMORY_ORDER_RELAXED);
458 if (entry->valueLength < PARAM_VALUE_LEN_MAX && valueLen < PARAM_VALUE_LEN_MAX) {
459 int ret = PARAM_MEMCPY(entry->data + entry->keyLength + 1, PARAM_VALUE_LEN_MAX, value, valueLen + 1);
460 PARAM_CHECK(ret == 0, return PARAM_CODE_INVALID_VALUE, "Failed to copy value");
461 entry->valueLength = valueLen;
462 }
463
464 uint32_t flags = commitId & ~PARAM_FLAGS_COMMITID;
465 uint32_t commitIdCount = (++commitId) & PARAM_FLAGS_COMMITID;
466 ATOMIC_STORE_EXPLICIT(&entry->commitId, flags | commitIdCount, MEMORY_ORDER_RELEASE);
467 ATOMIC_SYNC_ADD_AND_FETCH(&workSpace->area->commitId, 1, MEMORY_ORDER_RELEASE);
468 #ifdef PARAM_SUPPORT_SELINUX
469 WorkSpace *space = GetWorkSpace(WORKSPACE_INDEX_DAC);
470 if (space != NULL && space != workSpace) { // dac commit is global commit
471 ATOMIC_SYNC_ADD_AND_FETCH(&space->area->commitId, 1, MEMORY_ORDER_RELEASE);
472 }
473 #endif
474 PARAM_LOGV("UpdateParam name %s value: %s", name, value);
475
476 if (((unsigned int)mode & LOAD_PARAM_PERSIST) != 0) {
477 entry->commitId |= PARAM_FLAGS_PERSIST;
478 }
479 futex_wake(&entry->commitId, INT_MAX);
480 return 0;
481 }
482
WriteParam(const char * name,const char * value,uint32_t * dataIndex,int mode)483 INIT_LOCAL_API int WriteParam(const char *name, const char *value, uint32_t *dataIndex, int mode)
484 {
485 int flag = 0;
486 PARAM_LOGV("WriteParam %s", name);
487 ParamWorkSpace *paramSpace = GetParamWorkSpace();
488 PARAM_CHECK(paramSpace != NULL, return PARAM_WORKSPACE_NOT_INIT, "Invalid paramSpace");
489 PARAM_WORKSPACE_CHECK(paramSpace, return PARAM_WORKSPACE_NOT_INIT, "Invalid space");
490 PARAM_CHECK(value != NULL && name != NULL, return PARAM_CODE_INVALID_PARAM, "Invalid name or value");
491 WorkSpace *workSpace = GetWorkSpaceByName(name);
492 PARAM_CHECK(workSpace != NULL, return PARAM_CODE_INVALID_PARAM, "Invalid workSpace");
493 #ifdef PARAM_SUPPORT_SELINUX
494 if (strcmp(workSpace->fileName, WORKSPACE_NAME_DEF_SELINUX) == 0) {
495 flag = 1;
496 }
497 #endif
498 ParamTrieNode *node = FindTrieNode(workSpace, name, strlen(name), NULL);
499 int ret = 0;
500 if (node != NULL && node->dataIndex != 0) {
501 if (dataIndex != NULL) {
502 *dataIndex = node->dataIndex;
503 }
504 if ((mode & LOAD_PARAM_ONLY_ADD) == LOAD_PARAM_ONLY_ADD) {
505 return PARAM_CODE_READ_ONLY;
506 }
507 ParamNode *entry = (ParamNode *)GetTrieNode(workSpace, node->dataIndex);
508 PARAM_CHECK(entry != NULL, return PARAM_CODE_REACHED_MAX,
509 "Failed to update param value %s %u", name, node->dataIndex);
510 // use save type to check value
511 ret = CheckParamValue(node, name, value, entry->type);
512 PARAM_CHECK(ret == 0, return ret, "Invalid param value param: %s=%s", name, value);
513 PARAMSPACE_AREA_RW_LOCK(workSpace);
514 ret = UpdateParam(workSpace, &node->dataIndex, name, value, mode);
515 PARAMSPACE_AREA_RW_UNLOCK(workSpace);
516 } else {
517 uint8_t type = GetParamValueType(name);
518 ret = CheckParamValue(node, name, value, type);
519 PARAM_CHECK(ret == 0, return ret, "Invalid param value param: %s=%s", name, value);
520 PARAMSPACE_AREA_RW_LOCK(workSpace);
521 ret = AddParam((WorkSpace *)workSpace, type, name, value, dataIndex, mode);
522 PARAMSPACE_AREA_RW_UNLOCK(workSpace);
523 }
524 if ((ret == PARAM_CODE_REACHED_MAX) && (flag == 1)) {
525 PARAM_LOGE("Add node %s to space %s failed! memory is not enough, system reboot!", name, workSpace->fileName);
526 return PARAM_DEFAULT_PARAM_MEMORY_NOT_ENOUGH;
527 }
528 return ret;
529 }
530
GetNextWorkSpace(WorkSpace * curr)531 INIT_LOCAL_API WorkSpace *GetNextWorkSpace(WorkSpace *curr)
532 {
533 ParamWorkSpace *paramSpace = GetParamWorkSpace();
534 PARAM_CHECK(paramSpace != NULL, return NULL, "Invalid paramSpace");
535 uint32_t i = (curr == NULL) ? 0 : (curr->spaceIndex + 1);
536 WorkSpace *workSpace = NULL;
537 for (; i < paramSpace->maxLabelIndex; ++i) {
538 workSpace = GetWorkSpace(i);
539 if (workSpace != NULL) {
540 return workSpace;
541 }
542 }
543 return NULL;
544 }
545
GetParamValueType(const char * name)546 INIT_LOCAL_API uint8_t GetParamValueType(const char *name)
547 {
548 uint32_t labelIndex = 0;
549 WorkSpace *space = GetWorkSpace(WORKSPACE_INDEX_DAC);
550 if (space == NULL) {
551 return PARAM_TYPE_STRING;
552 }
553 (void)FindTrieNode(space, name, strlen(name), &labelIndex);
554 ParamSecurityNode *securityNode = (ParamSecurityNode *)GetTrieNode(space, labelIndex);
555 if (securityNode == NULL) {
556 return PARAM_TYPE_STRING;
557 }
558 return securityNode->type;
559 }
560
CheckParamValueType(const char * name,const char * value,uint8_t paramType)561 static int CheckParamValueType(const char *name, const char *value, uint8_t paramType)
562 {
563 (void)name;
564 if (paramType == PARAM_TYPE_INT) {
565 long long int temp1 = 0;
566 if (strlen(value) > 1 && value[0] == '-' && StringToLL(value, &temp1) != 0) {
567 PARAM_LOGE("Illegal param value %s for int", value);
568 return PARAM_CODE_INVALID_VALUE;
569 }
570 unsigned long long int temp2 = 0;
571 if (StringToULL(value, &temp2) != 0) {
572 PARAM_LOGE("Illegal param value %s for int", value);
573 return PARAM_CODE_INVALID_VALUE;
574 }
575 } else if (paramType == PARAM_TYPE_BOOL) {
576 static const char *validValue[] = {
577 "1", "0", "true", "false", "y", "yes", "on", "off", "n", "no"
578 };
579 size_t i = 0;
580 for (; i < ARRAY_LENGTH(validValue); i++) {
581 if (strcasecmp(validValue[i], value) == 0) {
582 break;
583 }
584 }
585 if (i >= ARRAY_LENGTH(validValue)) {
586 PARAM_LOGE("Illegal param value %s for bool", value);
587 return PARAM_CODE_INVALID_VALUE;
588 }
589 }
590 return 0;
591 }
592
CheckParamValue(const ParamTrieNode * node,const char * name,const char * value,uint8_t paramType)593 INIT_LOCAL_API int CheckParamValue(const ParamTrieNode *node, const char *name, const char *value, uint8_t paramType)
594 {
595 if (IS_READY_ONLY(name)) {
596 PARAM_CHECK(strlen(value) < PARAM_CONST_VALUE_LEN_MAX,
597 return PARAM_CODE_INVALID_VALUE, "Illegal param value %s", value);
598 if (node != NULL && node->dataIndex != 0) {
599 PARAM_LOGE("Read-only param was already set %s", name);
600 return PARAM_CODE_READ_ONLY;
601 }
602 } else {
603 PARAM_CHECK(strlen(value) < GetParamMaxLen(paramType),
604 return PARAM_CODE_INVALID_VALUE, "Illegal param value %s length", value);
605 }
606 return CheckParamValueType(name, value, paramType);
607 }
608
ReadParamName(ParamHandle handle,char * name,uint32_t length)609 static int ReadParamName(ParamHandle handle, char *name, uint32_t length)
610 {
611 PARAM_CHECK(name != NULL, return PARAM_CODE_INVALID_PARAM, "Invalid param");
612 ParamWorkSpace *paramSpace = GetParamWorkSpace();
613 PARAM_WORKSPACE_CHECK(paramSpace, return -1, "Param workspace has not init.");
614 PARAM_ONLY_CHECK(handle != (ParamHandle)-1, return PARAM_CODE_NOT_FOUND);
615 uint32_t labelIndex = 0;
616 uint32_t index = 0;
617 PARAM_GET_HANDLE_INFO(handle, labelIndex, index);
618 WorkSpace *workSpace = GetWorkSpace(labelIndex);
619 PARAM_CHECK(workSpace != NULL, return PARAM_CODE_NOT_FOUND, "Invalid workSpace for handle %x", handle);
620 ParamNode *entry = NULL;
621 if (PARAM_IS_ALIGNED(index)) {
622 entry = (ParamNode *)GetTrieNode(workSpace, index);
623 }
624 if (entry == NULL) {
625 return PARAM_CODE_NOT_FOUND;
626 }
627 PARAM_CHECK(length > entry->keyLength, return -1, "Invalid param size %u %u", entry->keyLength, length);
628 int ret = PARAM_MEMCPY(name, length, entry->data, entry->keyLength);
629 PARAM_CHECK(ret == 0, return PARAM_CODE_INVALID_PARAM, "Failed to copy name");
630 name[entry->keyLength] = '\0';
631 return 0;
632 }
633
CheckParamName(const char * name,int info)634 INIT_LOCAL_API int CheckParamName(const char *name, int info)
635 {
636 PARAM_CHECK(name != NULL, return PARAM_CODE_INVALID_PARAM, "Invalid param");
637 size_t nameLen = strlen(name);
638 if (nameLen >= PARAM_NAME_LEN_MAX) {
639 return PARAM_CODE_INVALID_NAME;
640 }
641 if (strcmp(name, "#") == 0) {
642 return 0;
643 }
644
645 if (nameLen < 1 || name[0] == '.' || (!info && name[nameLen - 1] == '.')) {
646 PARAM_LOGE("CheckParamName %s %d", name, info);
647 return PARAM_CODE_INVALID_NAME;
648 }
649
650 /* Only allow alphanumeric, plus '.', '-', '@', ':', or '_' */
651 /* Don't allow ".." to appear in a param name */
652 for (size_t i = 0; i < nameLen; i++) {
653 if (name[i] == '.') {
654 if (name[i - 1] == '.') {
655 return PARAM_CODE_INVALID_NAME;
656 }
657 continue;
658 }
659 if (name[i] == '_' || name[i] == '-' || name[i] == '@' || name[i] == ':') {
660 continue;
661 }
662 if (isalnum(name[i])) {
663 continue;
664 }
665 return PARAM_CODE_INVALID_NAME;
666 }
667 return 0;
668 }
669
CheckParamPermission_(WorkSpace ** workspace,ParamTrieNode ** node,const ParamSecurityLabel * srcLabel,const char * name,uint32_t mode)670 static int CheckParamPermission_(WorkSpace **workspace, ParamTrieNode **node,
671 const ParamSecurityLabel *srcLabel, const char *name, uint32_t mode)
672 {
673 ParamWorkSpace *paramSpace = GetParamWorkSpace();
674 PARAM_CHECK(srcLabel != NULL, return DAC_RESULT_FORBIDED, "The srcLabel is null");
675 WorkSpace *dacSpace = GetWorkSpace(WORKSPACE_INDEX_DAC);
676 PARAM_CHECK(paramSpace->checkParamPermission != NULL, return DAC_RESULT_FORBIDED, "Invalid check permission");
677 ParamLabelIndex labelIndex = {0};
678 // search node from dac space, and get selinux label index
679 *node = FindTrieNode(dacSpace, name, strlen(name), &labelIndex.dacLabelIndex);
680 labelIndex.workspace = GetWorkSpaceByName(name);
681 PARAM_CHECK(labelIndex.workspace != NULL, return DAC_RESULT_FORBIDED, "Invalid workSpace for %s", name);
682 labelIndex.selinuxLabelIndex = labelIndex.workspace->spaceIndex;
683
684 int ret = paramSpace->checkParamPermission(&labelIndex, srcLabel, name, mode);
685 PARAM_CHECK(ret == 0, return ret,
686 "Forbid to access %s label %u %u", name, labelIndex.dacLabelIndex, labelIndex.selinuxLabelIndex);
687 *workspace = labelIndex.workspace;
688 return ret;
689 }
690
CheckParamPermission(const ParamSecurityLabel * srcLabel,const char * name,uint32_t mode)691 INIT_LOCAL_API int CheckParamPermission(const ParamSecurityLabel *srcLabel, const char *name, uint32_t mode)
692 {
693 ParamTrieNode *entry = NULL;
694 WorkSpace *workspace = NULL;
695 return CheckParamPermission_(&workspace, &entry, srcLabel, name, mode);
696 }
697
GetTrieNodeByHandle(ParamHandle handle)698 STATIC_INLINE ParamTrieNode *GetTrieNodeByHandle(ParamHandle handle)
699 {
700 PARAM_ONLY_CHECK(handle != (ParamHandle)-1, return NULL);
701 uint32_t labelIndex = 0;
702 uint32_t index = 0;
703 PARAM_GET_HANDLE_INFO(handle, labelIndex, index);
704 WorkSpace *workSpace = GetWorkSpace(labelIndex);
705 PARAM_CHECK(workSpace != NULL, return NULL, "Invalid workSpace for handle %x", handle);
706 if (PARAM_IS_ALIGNED(index)) {
707 return (ParamTrieNode *)GetTrieNode(workSpace, index);
708 }
709 return NULL;
710 }
711
ReadParamValue(ParamNode * entry,char * value,uint32_t * length)712 STATIC_INLINE int ReadParamValue(ParamNode *entry, char *value, uint32_t *length)
713 {
714 if (entry == NULL) {
715 return PARAM_CODE_NOT_FOUND;
716 }
717 if (value == NULL) {
718 *length = entry->valueLength + 1;
719 return 0;
720 }
721 PARAM_CHECK(*length > entry->valueLength, return PARAM_CODE_INVALID_VALUE,
722 "Invalid value len %u %u", *length, entry->valueLength);
723 uint32_t commitId = ReadCommitId(entry);
724 return ReadParamValue_(entry, &commitId, value, length);
725 }
726
SystemReadParam(const char * name,char * value,uint32_t * len)727 int SystemReadParam(const char *name, char *value, uint32_t *len)
728 {
729 PARAM_WORKSPACE_CHECK(GetParamWorkSpace(), return PARAM_WORKSPACE_NOT_INIT,
730 "SystemReadParam failed! name is:%s, errNum is:%d!", name, PARAM_WORKSPACE_NOT_INIT);
731 PARAM_CHECK(name != NULL && len != NULL, return PARAM_CODE_ERROR,
732 "SystemReadParam failed! name is:%s, errNum is:%d!", name, PARAM_CODE_ERROR);
733 ParamTrieNode *node = NULL;
734 WorkSpace *workspace = NULL;
735 int ret = CheckParamPermission_(&workspace, &node, GetParamSecurityLabel(), name, DAC_READ);
736 if (ret != 0) {
737 PARAM_LOGE("SystemReadParam failed! name is:%s, errNum is:%d!", name, ret);
738 return ret;
739 }
740 #ifdef PARAM_SUPPORT_SELINUX
741 // search from real workspace
742 node = FindTrieNode(workspace, name, strlen(name), NULL);
743 #endif
744 if (node == NULL) {
745 return PARAM_CODE_NOT_FOUND;
746 }
747 ret = ReadParamValue((ParamNode *)GetTrieNode(workspace, node->dataIndex), value, len);
748 if (ret != 0) {
749 PARAM_LOGE("SystemReadParam failed! name is:%s, errNum is:%d!", name, ret);
750 }
751 return ret;
752 }
753
SystemFindParameter(const char * name,ParamHandle * handle)754 int SystemFindParameter(const char *name, ParamHandle *handle)
755 {
756 PARAM_WORKSPACE_CHECK(GetParamWorkSpace(), return PARAM_WORKSPACE_NOT_INIT, "Param workspace has not init.");
757 PARAM_CHECK(name != NULL && handle != NULL, return -1, "The name or handle is null");
758 *handle = -1;
759 ParamTrieNode *entry = NULL;
760 WorkSpace *workspace = NULL;
761 int ret = CheckParamPermission_(&workspace, &entry, GetParamSecurityLabel(), name, DAC_READ);
762 PARAM_CHECK(ret == 0, return ret, "Forbid to access parameter %s", name);
763 #ifdef PARAM_SUPPORT_SELINUX
764 // search from real workspace
765 entry = FindTrieNode(workspace, name, strlen(name), NULL);
766 #endif
767 if (entry != NULL && entry->dataIndex != 0) {
768 *handle = PARAM_HANDLE(workspace, entry->dataIndex);
769 return 0;
770 } else if (entry != NULL) {
771 return PARAM_CODE_NODE_EXIST;
772 }
773 return PARAM_CODE_NOT_FOUND;
774 }
775
SystemGetParameterCommitId(ParamHandle handle,uint32_t * commitId)776 int SystemGetParameterCommitId(ParamHandle handle, uint32_t *commitId)
777 {
778 PARAM_WORKSPACE_CHECK(GetParamWorkSpace(), return -1, "Param workspace has not init.");
779 PARAM_ONLY_CHECK(handle != (ParamHandle)-1, return PARAM_CODE_NOT_FOUND);
780 PARAM_CHECK(handle != 0 && commitId != NULL, return -1, "The handle is null");
781 ParamNode *entry = (ParamNode *)GetTrieNodeByHandle(handle);
782 if (entry == NULL) {
783 return PARAM_CODE_NOT_FOUND;
784 }
785 *commitId = ReadCommitId(entry);
786 return 0;
787 }
788
GetSystemCommitId(void)789 long long GetSystemCommitId(void)
790 {
791 PARAM_WORKSPACE_CHECK(GetParamWorkSpace(), return -1, "Param workspace has not init.");
792 WorkSpace *space = GetWorkSpace(WORKSPACE_INDEX_DAC);
793 if (space == NULL || space->area == NULL) {
794 return 0;
795 }
796 return ATOMIC_UINT64_LOAD_EXPLICIT(&space->area->commitId, MEMORY_ORDER_ACQUIRE);
797 }
798
SystemGetParameterValue(ParamHandle handle,char * value,unsigned int * len)799 int SystemGetParameterValue(ParamHandle handle, char *value, unsigned int *len)
800 {
801 PARAM_WORKSPACE_CHECK(GetParamWorkSpace(), return -1, "Param workspace has not init.");
802 PARAM_ONLY_CHECK(handle != (ParamHandle)-1, return PARAM_CODE_NOT_FOUND);
803 PARAM_CHECK(len != NULL && handle != 0, return -1, "The value is null");
804 return ReadParamValue((ParamNode *)GetTrieNodeByHandle(handle), value, len);
805 }
806
CheckIfUidInGroup(const gid_t groupId,const char * groupCheckName)807 INIT_LOCAL_API int CheckIfUidInGroup(const gid_t groupId, const char *groupCheckName)
808 {
809 PARAM_CHECK(groupCheckName != NULL, return -1, "Invalid groupCheckName");
810 struct group *groupName = getgrnam(groupCheckName);
811 PARAM_CHECK(groupName != NULL, return -1, "Not find %s group", groupCheckName);
812 char **gr_mem = groupName->gr_mem;
813 PARAM_CHECK(gr_mem != NULL, return -1, "No member in %s", groupCheckName);
814 for (int i = 0; gr_mem[i] != NULL; ++i) {
815 struct group *userGroup = getgrnam(gr_mem[i]);
816 if (userGroup != NULL) {
817 if (groupId == userGroup->gr_gid) {
818 return 0;
819 }
820 }
821 }
822 PARAM_LOGE("Forbid to access, groupId %u not in %s", groupId, groupCheckName);
823 return PARAM_CODE_PERMISSION_DENIED;
824 }
825