Merge branch 'master' of gitee.com:openharmony/startup_init_lite into param_init0428

Signed-off-by: NMupceet <laiguizhong@huawei.com>

interfaces/innerkits/fs_manager/fstab.c

 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -70,10 +70,10 @@ unsigned int ConvertFlags(char *flagBuffer)
     return flags;
 }
 
-static void AddToFstab(Fstab *fstab, FstabItem *item)
+static int AddToFstab(Fstab *fstab, FstabItem *item)
 {
     if (fstab == NULL || item == NULL) {
-        return;
+        return -1;
     }
     if (fstab->head != NULL) {
         item->next = fstab->head->next;
@@ -81,6 +81,7 @@ static void AddToFstab(Fstab *fstab, FstabItem *item)
     } else {
         fstab->head = item;
     }
+    return 0;
 }
 
 void ReleaseFstabItem(FstabItem *item)
@@ -124,14 +125,18 @@ void ReleaseFstab(Fstab *fstab)
     }
 }
 
-static int ParseFstabPerLine(char *str, Fstab *fstab, bool procMounts)
+int ParseFstabPerLine(char *str, Fstab *fstab, bool procMounts, const char *separator)
 {
     BEGET_CHECK_RETURN_VALUE(str != NULL && fstab != NULL, -1);
-    const char *separator = " \t";
     char *rest = NULL;
     FstabItem *item = NULL;
     char *p = NULL;
 
+    if (separator == NULL || *separator == '\0') {
+        BEGET_LOGE("Invalid separator for parsing fstab");
+        return -1;
+    }
+
     if ((item = (FstabItem *)calloc(1, sizeof(FstabItem))) == NULL) {
         errno = ENOMEM;
         BEGET_LOGE("Allocate memory for FS table item failed, err = %d", errno);
@@ -174,8 +179,7 @@ static int ParseFstabPerLine(char *str, Fstab *fstab, bool procMounts)
         } else {
             item->fsManagerFlags = 0;
         }
-        AddToFstab(fstab, item);
-        return 0;
+        return AddToFstab(fstab, item);
     } while (0);
 
     ReleaseFstabItem(item);
@@ -227,7 +231,7 @@ Fstab *ReadFstabFromFile(const char *file, bool procMounts)
             continue;
         }
 
-        if (ParseFstabPerLine(p, fstab, procMounts) < 0) {
+        if (ParseFstabPerLine(p, fstab, procMounts, " \t") < 0) {
             if (errno == ENOMEM) {
                 // Ran out of memory, there is no reason to continue.
                 break;
@@ -300,7 +304,7 @@ static char *GetFstabFile(char *fileName, int size)
         char hardware[MAX_BUFFER_LEN] = {0};
         char *buffer = ReadFileData("/proc/cmdline");
         if (buffer == NULL) {
-            BEGET_LOGE("Failed read \"/proc/cmdline\"");
+            BEGET_LOGE("Failed to read \"/proc/cmdline\"");
             return NULL;
         }
         int ret = GetProcCmdlineValue("hardware", buffer, hardware, MAX_BUFFER_LEN);
@@ -310,11 +314,11 @@ static char *GetFstabFile(char *fileName, int size)
             return NULL;
         }
         if (snprintf_s(fileName, size, size - 1, "/vendor/etc/fstab.%s", hardware) == -1) {
-            BEGET_LOGE("Fail snprintf_s err=%d", errno);
+            BEGET_LOGE("Failed to build fstab file, err=%d", errno);
             return NULL;
         }
     }
-    BEGET_LOGI("file is %s", fileName);
+    BEGET_LOGI("fstab file is %s", fileName);
     return fileName;
 }
 
@@ -325,11 +329,11 @@ int GetBlockDeviceByMountPoint(const char *mountPoint, const Fstab *fstab, char
     }
     FstabItem *item = FindFstabItemForMountPoint(*fstab, mountPoint);
     if (item == NULL) {
-        BEGET_LOGE("Failed get fstab item from point \" %s \"", mountPoint);
+        BEGET_LOGE("Failed to get fstab item from point \" %s \"", mountPoint);
         return -1;
     }
     if (strncpy_s(deviceName, nameLen, item->deviceName, strlen(item->deviceName)) != 0) {
-        BEGET_LOGE("Failed strncpy_s err=%d", errno);
+        BEGET_LOGE("Failed to copy block device name, err=%d", errno);
         return -1;
     }
     return 0;
@@ -416,7 +420,7 @@ unsigned long GetMountFlags(char *mountFlag, char *fsSpecificData, size_t fsSpec
             }
             // Combined each mount flag with ','
             if (strncat_s(fsSpecificData, fsSpecificDataSize - 1, ",", 1) != EOK) {
-                BEGET_LOGW("Failed to append comma.");
+                BEGET_LOGW("Failed to append comma");
                 break; // If cannot add ',' to the end of flags, there is not reason to continue.
             }
         }

interfaces/innerkits/include/fs_manager/fs_manager.h

 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -60,6 +60,7 @@ void ReleaseFstab(Fstab *fstab);
 Fstab *ReadFstabFromFile(const char *file, bool procMounts);
 FstabItem *FindFstabItemForPath(Fstab fstab, const char *path);
 FstabItem* FindFstabItemForMountPoint(Fstab fstab, const char *mp);
+int ParseFstabPerLine(char *str, Fstab *fstab, bool procMounts, const char *separator);
 
 int GetBlockDeviceByMountPoint(const char *mountPoint, const Fstab *fstab, char *deviceName, int nameLen);
 bool IsSupportedFilesystem(const char *fsType);

services/init/include/init_service.h

@@ -141,6 +141,7 @@ typedef struct Service_ {
     uint64_t tokenId;
     char apl[MAX_APL_NAME + 1];
     ServiceArgs capsArgs;
+    ServiceArgs permArgs;
     Perms servPerm;
     ServiceArgs pathArgs;
     ServiceArgs extraArgs;

services/init/init_service_manager.c

@@ -204,6 +204,7 @@ void ReleaseService(Service *service)
     FreeServiceArg(&service->pathArgs);
     FreeServiceArg(&service->writePidArgs);
     FreeServiceArg(&service->capsArgs);
+    FreeServiceArg(&service->permArgs);
 
     if (service->servPerm.caps != NULL) {
         free(service->servPerm.caps);
@@ -807,6 +808,7 @@ int ParseOneService(const cJSON *curItem, Service *service)
 
     (void)GetServiceArgs(curItem, "writepid", MAX_WRITEPID_FILES, &service->writePidArgs);
     (void)GetServiceArgs(curItem, D_CAPS_STR_IN_CFG, MAX_WRITEPID_FILES, &service->capsArgs);
+    (void)GetServiceArgs(curItem, "permission", MAX_WRITEPID_FILES, &service->permArgs);
     (void)GetStringItem(curItem, APL_STR_IN_CFG, service->apl, MAX_APL_NAME);
     (void)GetCpuArgs(curItem, CPU_CORE_STR_IN_CFG, service);
     ret = GetServiceSandbox(curItem, service);

services/init/standard/init.c

 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -173,16 +173,9 @@ static int StartUeventd(char **requiredDevices, int num)
 
 static void StartInitSecondStage(void)
 {
-    const char *fstabFile = "/etc/fstab.required";
-    Fstab *fstab = NULL;
-    if (access(fstabFile, F_OK) != 0) {
-        fstabFile = "/system/etc/fstab.required";
-    }
-    INIT_ERROR_CHECK(access(fstabFile, F_OK) == 0, abort(), "Failed get fstab.required");
-    fstab = ReadFstabFromFile(fstabFile, false);
-    INIT_ERROR_CHECK(fstab != NULL, abort(), "Read fstab file \" %s \" failed\n", fstabFile);
-
     int requiredNum = 0;
+    Fstab* fstab = LoadRequiredFstab();
+    INIT_ERROR_CHECK(fstab != NULL, abort(), "Failed to load required fstab");
     char **devices = GetRequiredDevices(*fstab, &requiredNum);
     if (devices != NULL && requiredNum > 0) {
         int ret = StartUeventd(devices, requiredNum);

services/init/standard/init_mount.c

 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -13,15 +13,133 @@
  * limitations under the License.
  */
 
+#include "init_mount.h"
+
+#include <errno.h>
+#include <stdbool.h>
 #include "fs_manager/fs_manager.h"
 #include "init_cmds.h"
 #include "init_log.h"
+#include "init_utils.h"
+#include "securec.h"
 
 int MountRequriedPartitions(const Fstab *fstab)
 {
-    INIT_ERROR_CHECK(fstab != NULL, return -1, "Failed fstab is NULL");
+    INIT_ERROR_CHECK(fstab != NULL, return -1, "fstab is NULL");
     int rc;
     INIT_LOGI("Mount required partitions");
     rc = MountAllWithFstab(fstab, 1);
     return rc;
 }
+
+#define OHOS_REQUIRED_MOUNT_PREFIX "ohos.required_mount."
+static int ParseRequiredMountInfo(const char *item, Fstab *fstab)
+{
+    char mountOptions[MAX_BUFFER_LEN] = {};
+    char partName[PARTITION_NAME_SIZE] = {};
+    // Sanity checks
+    if (item == NULL || *item == '\0' || fstab == NULL) {
+        return -1;
+    }
+
+    char *p = NULL;
+    const char *q = item;
+    if ((p = strstr(item, "=")) != NULL) {
+        q = item + strlen(OHOS_REQUIRED_MOUNT_PREFIX); // Get partition name
+        if (q == NULL || *q == '\0' || (p - q) <= 0) {
+            return -1;
+        }
+        if (strncpy_s(partName, PARTITION_NAME_SIZE -1, q, p - q) != EOK) {
+            INIT_LOGE("Failed to copy requried partition name");
+            return -1;
+        }
+        p++; // skip '='
+        if (strncpy_s(mountOptions, MAX_BUFFER_LEN -1, p, strlen(p)) != EOK) {
+            INIT_LOGE("Failed to copy requried mount info: %s", item);
+            return -1;
+        }
+    }
+    INIT_LOGV("Mount option of partition %s is [%s]", partName, mountOptions);
+    if (ParseFstabPerLine(mountOptions, fstab, false, "@") < 0) {
+        INIT_LOGE("Failed to parse mount options of partition \' %s \', options: %s", partName, mountOptions);
+        return -1;
+    }
+    return 0;
+}
+
+static Fstab* LoadFstabFromCommandLine(void)
+{
+    Fstab *fstab = NULL;
+    char *cmdline = ReadFileData("/proc/cmdline");
+    bool isDone = false;
+
+    if (cmdline == NULL) {
+        INIT_LOGE("Read from \'/proc/cmdline\' failed, err = %d", errno);
+        return NULL;
+    }
+    if ((fstab = (Fstab *)calloc(1, sizeof(Fstab))) == NULL) {
+        INIT_LOGE("Allocate memory for FS table failed, err = %d", errno);
+        return NULL;
+    }
+
+    char *start = cmdline;
+    char *end = start + strlen(cmdline);
+    while (start < end) {
+        char *token = strstr(start, " ");
+        if (token == NULL) {
+            break;
+        }
+
+        // Startswith " "
+        if (token == start) {
+            start++;
+            continue;
+        }
+        *token = '\0';
+        if (strncmp(start, OHOS_REQUIRED_MOUNT_PREFIX,
+            strlen(OHOS_REQUIRED_MOUNT_PREFIX)) != 0) {
+            start = token + 1;
+            continue;
+        }
+        isDone = true;
+        if (ParseRequiredMountInfo(start, fstab) < 0) {
+            INIT_LOGE("Failed to parse \' %s \'", start);
+            isDone = false;
+            break;
+        }
+        start = token + 1;
+    }
+
+    // handle last one
+    if (start < end) {
+        if (strncmp(start, OHOS_REQUIRED_MOUNT_PREFIX,
+            strlen(OHOS_REQUIRED_MOUNT_PREFIX)) == 0 &&
+            ParseRequiredMountInfo(start, fstab) < 0) {
+            INIT_LOGE("Failed to parse \' %s \'", start);
+            isDone = false;
+        }
+    }
+
+    if (!isDone) {
+        ReleaseFstab(fstab);
+        fstab = NULL;
+    }
+    free(cmdline);
+    return fstab;
+}
+
+Fstab* LoadRequiredFstab(void)
+{
+    Fstab *fstab = NULL;
+    fstab = LoadFstabFromCommandLine();
+    if (fstab == NULL) {
+        INIT_LOGI("Cannot load fstab from command line, try read from fstab.required");
+        const char *fstabFile = "/etc/fstab.required";
+        if (access(fstabFile, F_OK) != 0) {
+            fstabFile = "/system/etc/fstab.required";
+        }
+        INIT_ERROR_CHECK(access(fstabFile, F_OK) == 0, abort(), "Failed get fstab.required");
+        fstab = ReadFstabFromFile(fstabFile, false);
+    }
+    return fstab;
+}

services/init/standard/init_mount.h

 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -23,6 +23,8 @@
 extern "C" {
 #endif
 #endif
+#define PARTITION_NAME_SIZE 32
+Fstab* LoadRequiredFstab(void);
 int MountRequriedPartitions(const Fstab *fstab);
 #ifdef __cplusplus
 #if __cplusplus

services/init/standard/init_reboot.c

@@ -121,14 +121,16 @@ static int CheckAndRebootToUpdater(const char *valueData, const char *cmd,
         INIT_ERROR_CHECK(ret == 0, return -1, "Failed to format cmd for %s.", cmd);
     }
 
-    if ((cmdExt != NULL) && (valueData != NULL) && (strncmp(valueData, cmdExt, strlen(cmdExt)) == 0)) {
-        const char *p = valueData + strlen(cmdExt);
-        ret = snprintf_s(msg.update, MAX_UPDATE_SIZE, MAX_UPDATE_SIZE - 1, "%s", p);
-        INIT_ERROR_CHECK(ret > 0, return -1, "Failed to format param for %s.", cmd);
-        msg.update[MAX_UPDATE_SIZE - 1] = 0;
-    } else {
-        ret = memset_s(msg.update, MAX_UPDATE_SIZE, 0, MAX_UPDATE_SIZE);
-        INIT_ERROR_CHECK(ret == 0, return -1, "Failed to format update for %s.", cmd);
+    if (strncmp(cmd, "updater", strlen("updater")) != 0) {
+        if ((cmdExt != NULL) && (valueData != NULL) && (strncmp(valueData, cmdExt, strlen(cmdExt)) == 0)) {
+            const char *p = valueData + strlen(cmdExt);
+            ret = snprintf_s(msg.update, MAX_UPDATE_SIZE, MAX_UPDATE_SIZE - 1, "%s", p);
+            INIT_ERROR_CHECK(ret > 0, return -1, "Failed to format param for %s.", cmd);
+            msg.update[MAX_UPDATE_SIZE - 1] = 0;
+        } else {
+            ret = memset_s(msg.update, MAX_UPDATE_SIZE, 0, MAX_UPDATE_SIZE);
+            INIT_ERROR_CHECK(ret == 0, return -1, "Failed to format update for %s.", cmd);
+        }
     }
 
     if (RBMiscWriteUpdaterMessage(miscFile, &msg) == 0) {

services/init/standard/init_service.c

@@ -119,8 +119,15 @@ void GetAccessToken(void)
             if (strlen(service->apl) == 0) {
                 (void)strncpy_s(service->apl, sizeof(service->apl), "system_core", sizeof(service->apl) - 1);
             }
-            uint64_t tokenId = GetAccessTokenId(service->name, (const char **)service->capsArgs.argv,
-                service->capsArgs.count, service->apl);
+            NativeTokenInfoParams nativeTokenInfoParams = {
+                service->capsArgs.count,
+                service->permArgs.count,
+                (const char **)service->capsArgs.argv,
+                (const char **)service->permArgs.argv,
+                service->name,
+                service->apl,
+            };
+            uint64_t tokenId = GetAccessTokenId(&nativeTokenInfoParams);
             if (tokenId  == 0) {
                 INIT_LOGE("Get totken id %lld of service \' %s \' failed", tokenId, service->name);
             }

services/plugin/bootchart/bootchart.c

@@ -308,6 +308,4 @@ static void BootchartExit(void)
 PLUGIN_CONSTRUCTOR(void)
 {
     PluginRegister("bootchart", NULL, BootchartInit, BootchartExit);
-    PLUGIN_LOGI("bootchart pluginInterface %p %p",
-        BootchartInit, BootchartExit);
 }

test/fuzztest/systemdumpparameters_fuzzer/systemdumpparameters_fuzzer.cpp

@@ -21,7 +21,8 @@ namespace OHOS {
     bool FuzzSystemDumpParameters(const uint8_t* data, size_t size)
     {
         CloseStdout();
-        SystemDumpParameters(reinterpret_cast<int>(data));
+        int verbose = atoi(reinterpret_cast<char *>(const_cast<uint8_t *>(data)));
+        SystemDumpParameters(verbose);
         return true;
     }
 }

test/fuzztest/systemgetparametercommitid_fuzzer/systemgetparametercommitid_fuzzer.cpp

@@ -15,13 +15,16 @@
 
 #include "systemgetparametercommitid_fuzzer.h"
 #include "init_param.h"
+#include "fuzz_utils.h"
 
 namespace OHOS {
     bool FuzzSystemGetParameterCommitId(const uint8_t* data, size_t size)
     {
         bool result = false;
         uint32_t commitId = 0;
-        if (!SystemGetParameterCommitId(reinterpret_cast<ParamHandle>(data), &commitId)) {
+        char *rest = nullptr;
+        ParamHandle handle = (ParamHandle)strtoul(reinterpret_cast<char *>(const_cast<uint8_t *>(data)), &rest, BASE);
+        if (!SystemGetParameterCommitId(handle, &commitId)) {
             result = true;
         }
         return result;

test/fuzztest/systemgetparametername_fuzzer/systemgetparametername_fuzzer.cpp

@@ -15,13 +15,16 @@
 
 #include "systemgetparametername_fuzzer.h"
 #include "init_param.h"
+#include "fuzz_utils.h"
 
 namespace OHOS {
     bool FuzzSystemGetParameterName(const uint8_t* data, size_t size)
     {
         bool result = false;
         char buffer[PARAM_NAME_LEN_MAX] = {0};
-        if (!SystemGetParameterName(reinterpret_cast<ParamHandle>(data), buffer, PARAM_NAME_LEN_MAX)) {
+        char *rest = nullptr;
+        ParamHandle handle = (ParamHandle)strtoul(reinterpret_cast<char *>(const_cast<uint8_t *>(data)), &rest, BASE);
+        if (!SystemGetParameterName(handle, buffer, PARAM_NAME_LEN_MAX)) {
             result = true;
         }
         return result;

test/fuzztest/systemgetparametervalue_fuzzer/systemgetparametervalue_fuzzer.cpp

@@ -15,6 +15,7 @@
 
 #include "systemgetparametervalue_fuzzer.h"
 #include "init_param.h"
+#include "fuzz_utils.h"
 
 namespace OHOS {
     bool FuzzSystemGetParameterValue(const uint8_t* data, size_t size)
@@ -22,7 +23,9 @@ namespace OHOS {
         bool result = false;
         char buffer[PARAM_CONST_VALUE_LEN_MAX] = {0};
         uint32_t len = PARAM_CONST_VALUE_LEN_MAX;
-        if (!SystemGetParameterValue(reinterpret_cast<ParamHandle>(data), buffer, &len)) {
+        char *rest = nullptr;
+        ParamHandle handle = (ParamHandle)strtoul(reinterpret_cast<char *>(const_cast<uint8_t *>(data)), &rest, BASE);
+        if (!SystemGetParameterValue(handle, buffer, &len)) {
             result = true;
         }
         return result;

test/fuzztest/utils/include/fuzz_utils.h

@@ -18,5 +18,6 @@
 #include <stdint.h>
 #include <stdlib.h>
 
+#define BASE 10
 void CloseStdout(void);
 #endif

ueventd/etc/ueventd.config

@@ -70,3 +70,4 @@
 /dev/tty0 0660 0 1000
 /dev/uinput 0660 3011 3011
 /dev/access_token_id 0666 3020 3020
+/dev/block/by-name/misc 0660 6666 6666