!277 modify: ondemand ueventd and format socket

Merge pull request !277 from 熊磊/init0127xyt

interfaces/innerkits/socket/BUILD.gn

@@ -11,7 +11,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import("//build/ohos.gni")
 service_socket_sources =
     [ "//base/startup/init_lite/interfaces/innerkits/socket/init_socket.c" ]
 service_socket_include = [
@@ -24,19 +23,31 @@ service_socket_deps = [
   "//third_party/bounds_checking_function:libsec_static",
 ]
 
-ohos_static_library("libsocket_static") {
-  sources = service_socket_sources
-  include_dirs = service_socket_include
-  deps = service_socket_deps
-}
+if (defined(ohos_lite)) {
+  if (ohos_kernel_type == "linux") {
+    static_library("libsocket_static") {
+      sources = service_socket_sources
+      include_dirs = service_socket_include
+      deps = service_socket_deps
+    }
+  }
+} else {
+  import("//build/ohos.gni")
+
+  ohos_static_library("libsocket_static") {
+    sources = service_socket_sources
+    include_dirs = service_socket_include
+    deps = service_socket_deps
+  }
 
-ohos_shared_library("libsocket") {
-  sources = service_socket_sources
-  include_dirs = service_socket_include
-  deps = service_socket_deps
-  part_name = "init"
-  install_images = [
-    "system",
-    "updater",
-  ]
+  ohos_shared_library("libsocket") {
+    sources = service_socket_sources
+    include_dirs = service_socket_include
+    deps = service_socket_deps
+    part_name = "init"
+    install_images = [
+      "system",
+      "updater",
+    ]
+  }
 }

interfaces/innerkits/socket/init_socket.c

@@ -53,9 +53,17 @@ int GetControlSocket(const char *name)
     BEGET_LOGI("GetControlSocket path is %s ", path);
     int fd = GetControlFromEnv(path, MAX_SOCKET_ENV_PREFIX_LEN);
     BEGET_ERROR_CHECK(fd >= 0, return -1, "GetControlFromEnv fail ");
+    int addrFamily = 0;
+    socklen_t afLen = sizeof(addrFamily);
+    int ret = getsockopt(fd, SOL_SOCKET, SO_DOMAIN, &addrFamily, &afLen);
+    BEGET_ERROR_CHECK(ret == 0, return -1, "get socket option fail, errno %d ", errno);
+    BEGET_LOGI("socket %s fd %d address family %d", name, fd, addrFamily);
+    if (addrFamily != AF_UNIX) {
+        return fd;
+    }
     struct sockaddr_un addr;
     socklen_t addrlen = sizeof(addr);
-    int ret = getsockname(fd, (struct sockaddr*)&addr, &addrlen);
+    ret = getsockname(fd, (struct sockaddr*)&addr, &addrlen);
     BEGET_ERROR_CHECK(ret >= 0, return -1, "GetControlSocket errno %d ", errno);
     char sockDir[MAX_SOCKET_DIR_LEN] = {0};
     BEGET_CHECK_RETURN_VALUE(snprintf_s(sockDir, sizeof(sockDir), sizeof(sockDir) - 1, OHOS_SOCKET_DIR"/%s",

services/BUILD.gn

@@ -31,6 +31,7 @@ if (defined(ohos_lite)) {
       "_GNU_SOURCE",  #syscall function need this macro definition
       "OHOS_LITE",
     ]
+    defines += [ "__MUSL__" ]
     sources = [
       "init/adapter/init_adapter.c",
       "init/lite/init.c",

services/etc/init.cfg

@@ -427,7 +427,23 @@
     "services" : [{
             "name" : "ueventd",
             "path" : ["/system/bin/ueventd"],
-            "critical" : 1
+            "socket" : [{
+                "name" : "ueventd",
+                "family" : "AF_NETLINK",
+                "type" : "SOCK_DGRAM",
+                "protocol" : "NETLINK_KOBJECT_UEVENT",
+                "permissions" : "0660",
+                "uid" : "system",
+                "gid" : "system",
+                "option" : [
+                    "SOCKET_OPTION_PASSCRED",
+                    "SOCKET_OPTION_RCVBUFFORCE",
+                    "SOCK_CLOEXEC",
+                    "SOCK_NONBLOCK"
+                ]
+            }],
+            "critical" : [ 0, 15, 5],
+            "ondemand" : true
         }, {
             "name" : "console",
             "path" : ["/system/bin/sh"],

services/etc/init.usb.cfg

@@ -19,9 +19,15 @@
     "services" : [{
             "name" : "hdcd",
             "path" : ["/system/bin/hdcd"],
-            "socket" : [
-                "hdcd seqpacket 660 system system false"
-            ],
+            "socket" : [{
+                "name" : "hdcd",
+                "family" : "AF_UNIX",
+                "type" : "SOCK_SEQPACKET",
+                "protocol" : "default",
+                "permissions" : "0660",
+                "uid" : "system",
+                "gid" : "system"
+            }],
             "disabled" : 1
         }
     ]

services/init/include/init_service.h

@@ -14,8 +14,9 @@
  */
 #ifndef BASE_STARTUP_INITLITE_SERVICE_H
 #define BASE_STARTUP_INITLITE_SERVICE_H
-#include <sys/types.h>
+#include <stdbool.h>
 #include <stdint.h>
+#include <sys/types.h>
 
 #include "cJSON.h"
 #include "init_cmds.h"
@@ -49,6 +50,7 @@ extern "C" {
 
 #define MAX_SERVICE_NAME 32
 #define MAX_APL_NAME 32
+#define MAX_ENV_NAME 64
 #define MAX_JOB_NAME 128
 #define MAX_WRITEPID_FILES 100
 

services/init/include/init_service_socket.h

@@ -14,10 +14,13 @@
  */
 #ifndef INIT_SERVICE_SOCKET_
 #define INIT_SERVICE_SOCKET_
-#include <stdbool.h>
+#ifndef __LITEOS__
+#include <linux/netlink.h>
+#endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/types.h>
+#include <sys/un.h>
 #include <unistd.h>
 #ifdef __cplusplus
 #if __cplusplus
@@ -41,16 +44,31 @@ enum SockOptionTab {
 };
 typedef void *ServiceWatcher;
 struct Service_;
+
+// socket option
+#define SOCKET_OPTION_INVALID 0x001      // option invalid
+#define SOCKET_OPTION_PASSCRED 0x002     // SO_PASSCRED
+#define SOCKET_OPTION_RCVBUFFORCE 0x004  // SO_RCVBUFFORCE
+
+typedef union {
+#ifndef __LITEOS__
+    struct sockaddr_nl addrnl;
+#endif
+    struct sockaddr_un addrun;
+} sockaddr_union;
+
 typedef struct ServiceSocket_ {
     struct ServiceSocket_ *next;
-    int type;      // socket type
-    uid_t uid;     // uid
-    gid_t gid;     // gid
-    bool passcred; // setsocketopt
-    mode_t perm;   // Setting permissions
+    int family;          // socket family
+    unsigned int type;   // socket type
+    int protocol;        // socket protocol
+    mode_t perm;         // Setting permissions
+    uid_t uid;           // uid
+    gid_t gid;           // gid
+    unsigned int option; // setsocketopt
     int sockFd;
     ServiceWatcher watcher;
-    char name[0]; // service name
+    char name[0];        // service name
 } ServiceSocket;
 
 int CreateServiceSocket(struct Service_ *service);

services/init/init_service_manager.c

@@ -191,16 +191,21 @@ void ReleaseService(Service *service)
     free(service);
 }
 
+static char *GetStringValue(const cJSON *json, const char *name, size_t *strLen)
+{
+    char *fieldStr = cJSON_GetStringValue(cJSON_GetObjectItem(json, name));
+    INIT_ERROR_CHECK(fieldStr != NULL, return NULL, "Failed to get string for %s", name);
+    *strLen = strlen(fieldStr);
+    return fieldStr;
+}
+
 static int GetStringItem(const cJSON *json, const char *name, char *buffer, int buffLen)
 {
     INIT_ERROR_CHECK(json != NULL, return SERVICE_FAILURE, "Invalid json for %s", name);
-    char *fieldStr = cJSON_GetStringValue(cJSON_GetObjectItem(json, name));
-    if (fieldStr == NULL) {
-        return SERVICE_FAILURE;
-    }
-    size_t strLen = strlen(fieldStr);
-    INIT_ERROR_CHECK((strLen != 0) && (strLen <= (size_t)buffLen), return SERVICE_FAILURE,
-        "Invalid str filed %s for %s", fieldStr, name);
+    size_t strLen = 0;
+    char *fieldStr = GetStringValue(json, name, &strLen);
+    INIT_ERROR_CHECK((fieldStr != NULL) && (strLen != 0) && (strLen <= (size_t)buffLen),
+        return SERVICE_FAILURE, "Invalid str filed %s for %s", fieldStr, name);
     return strcpy_s(buffer, buffLen, fieldStr);
 }
 
@@ -317,50 +322,130 @@ static int GetServiceAttr(const cJSON *curArrItem, Service *curServ, const char
     return processAttr(curServ, attrName, value, flag);
 }
 
-static int AddServiceSocket(cJSON *json, Service *service)
+static int ParseSocketFamily(cJSON *json, ServiceSocket *sockopt)
 {
-    char *opt[SOCK_OPT_NUMS] = {
-        NULL,
-    };
-    INIT_CHECK_RETURN_VALUE(cJSON_IsString(json) && cJSON_GetStringValue(json), SERVICE_FAILURE);
-    char *sockStr = cJSON_GetStringValue(json);
-    int num = SplitString(sockStr, " ", opt, SOCK_OPT_NUMS);
-    INIT_CHECK_RETURN_VALUE(num == SOCK_OPT_NUMS, SERVICE_FAILURE);
-
-    if (opt[SERVICE_SOCK_NAME] == NULL || opt[SERVICE_SOCK_TYPE] == NULL || opt[SERVICE_SOCK_PERM] == NULL ||
-        opt[SERVICE_SOCK_UID] == NULL || opt[SERVICE_SOCK_GID] == NULL || opt[SERVICE_SOCK_SETOPT] == NULL) {
-        INIT_LOGE("Invalid socket opt");
-        return SERVICE_FAILURE;
+    sockopt->family = AF_UNIX;
+    size_t strLen = 0;
+    char *stringValue = GetStringValue(json, "family", &strLen);
+    INIT_ERROR_CHECK((stringValue != NULL) && (strLen > 0), return SERVICE_FAILURE,
+        "Failed to get string for family");
+    if (strncmp(stringValue, "AF_UNIX", strLen) == 0) {
+        sockopt->family = AF_UNIX;
+    } else if (strncmp(stringValue, "AF_NETLINK", strLen) == 0) {
+        sockopt->family = AF_NETLINK;
     }
+    return 0;
+}
 
-    ServiceSocket *sockopt = (ServiceSocket *)calloc(1, sizeof(ServiceSocket) + strlen(opt[SERVICE_SOCK_NAME]) + 1);
-    INIT_INFO_CHECK(sockopt != NULL, return SERVICE_FAILURE, "Failed to malloc for socket %s", opt[SERVICE_SOCK_NAME]);
-    sockopt->sockFd = -1;
-    int ret = strcpy_s(sockopt->name, strlen(opt[SERVICE_SOCK_NAME]) + 1, opt[SERVICE_SOCK_NAME]);
-    INIT_INFO_CHECK(ret == 0, free(sockopt);
-        return SERVICE_FAILURE, "Failed to copy socket name %s", opt[SERVICE_SOCK_NAME]);
-
+static int ParseSocketType(cJSON *json, ServiceSocket *sockopt)
+{
     sockopt->type = SOCK_SEQPACKET;
-    if (strncmp(opt[SERVICE_SOCK_TYPE], "stream", strlen(opt[SERVICE_SOCK_TYPE])) == 0) {
+    size_t strLen = 0;
+    char *stringValue = GetStringValue(json, "type", &strLen);
+    INIT_ERROR_CHECK((stringValue != NULL) && (strLen > 0), return SERVICE_FAILURE,
+        "Failed to get string for type");
+    if (strncmp(stringValue, "SOCK_SEQPACKET", strLen) == 0) {
+        sockopt->type = SOCK_SEQPACKET;
+    } else if (strncmp(stringValue, "SOCK_STREAM", strLen) == 0) {
         sockopt->type = SOCK_STREAM;
-    } else if (strncmp(opt[SERVICE_SOCK_TYPE], "dgram", strlen(opt[SERVICE_SOCK_TYPE])) == 0) {
+    } else if (strncmp(stringValue, "SOCK_DGRAM", strLen) == 0) {
         sockopt->type = SOCK_DGRAM;
     }
-    sockopt->perm = strtoul(opt[SERVICE_SOCK_PERM], 0, OCTAL_BASE);
-    sockopt->uid = DecodeUid(opt[SERVICE_SOCK_UID]);
-    sockopt->gid = DecodeUid(opt[SERVICE_SOCK_GID]);
-    if (sockopt->uid == (uid_t)-1 || sockopt->gid == (uid_t)-1) {
-        free(sockopt);
-        sockopt = NULL;
-        INIT_LOGE("Invalid uid or gid");
-        return SERVICE_FAILURE;
+    return 0;
+}
+
+static int ParseSocketProtocol(cJSON *json, ServiceSocket *sockopt)
+{
+    sockopt->protocol = 0;
+    size_t strLen = 0;
+    char *stringValue = GetStringValue(json, "protocol", &strLen);
+    INIT_ERROR_CHECK((stringValue != NULL) && (strLen > 0), return SERVICE_FAILURE,
+        "Failed to get string for protocol");
+    if (strncmp(stringValue, "default", strLen) == 0) {
+        sockopt->protocol = 0;
+    } else if (strncmp(stringValue, "NETLINK_KOBJECT_UEVENT", strLen) == 0) {
+#ifndef __LITEOS__
+        sockopt->protocol = NETLINK_KOBJECT_UEVENT;
+#else
+        return -1;
+#endif
     }
-    sockopt->passcred = false;
-    if (strncmp(opt[SERVICE_SOCK_SETOPT], "passcred", strlen(opt[SERVICE_SOCK_SETOPT])) == 0) {
-        sockopt->passcred = true;
+    return 0;
+}
+
+static int ParseSocketOption(cJSON *json, ServiceSocket *sockopt)
+{
+    sockopt->option = 0;
+    unsigned int tempType = 0;
+    int typeCnt = 0;
+    char *stringValue = NULL;
+    cJSON *typeItem = NULL;
+    cJSON *typeArray = GetArrayItem(json, &typeCnt, "option");
+    INIT_CHECK((typeArray != NULL) && (typeCnt > 0), return 0);
+    for (int i = 0; i < typeCnt; ++i) {
+        typeItem = cJSON_GetArrayItem(typeArray, i);
+        INIT_CHECK_RETURN_VALUE(cJSON_IsString(typeItem), SERVICE_FAILURE);
+        stringValue = cJSON_GetStringValue(typeItem);
+        INIT_ERROR_CHECK(stringValue != NULL, return SERVICE_FAILURE, "Failed to get string for type");
+        if (strncmp(stringValue, "SOCKET_OPTION_PASSCRED", strlen(stringValue)) == 0) {
+            sockopt->option |= SOCKET_OPTION_PASSCRED;
+        } else if (strncmp(stringValue, "SOCKET_OPTION_RCVBUFFORCE", strlen(stringValue)) == 0) {
+            sockopt->option |= SOCKET_OPTION_RCVBUFFORCE;
+        } else if (strncmp(stringValue, "SOCK_CLOEXEC", strlen(stringValue)) == 0) {
+            tempType |= SOCK_CLOEXEC;
+        } else if (strncmp(stringValue, "SOCK_NONBLOCK", strlen(stringValue)) == 0) {
+            tempType |= SOCK_NONBLOCK;
+        }
     }
-    sockopt->watcher = NULL;
+    if (tempType != 0) {
+        sockopt->type |= tempType;
+    }
+    return 0;
+}
+
+static int AddServiceSocket(cJSON *json, Service *service)
+{
+    size_t strLen = 0;
+    char* fieldStr = GetStringValue(json, "name", &strLen);
+    INIT_ERROR_CHECK(fieldStr != NULL, return SERVICE_FAILURE, "Failed to get socket name");
+    INIT_ERROR_CHECK(strLen <= MAX_SERVICE_NAME, return SERVICE_FAILURE, "socket name exceeds length limit");
+    ServiceSocket *sockopt = (ServiceSocket *)calloc(1, sizeof(ServiceSocket) + strLen + 1);
+    INIT_INFO_CHECK(sockopt != NULL, return SERVICE_FAILURE, "Failed to malloc for service %s", service->name);
+
+    int ret = strcpy_s(sockopt->name, strLen + 1, fieldStr);
+    INIT_INFO_CHECK(ret == 0, free(sockopt); sockopt = NULL; return SERVICE_FAILURE,
+        "Failed to copy socket name %s", fieldStr);
     sockopt->sockFd = -1;
+    sockopt->watcher = NULL;
+
+    ret = ParseSocketFamily(json, sockopt);
+    INIT_ERROR_CHECK(ret == 0, free(sockopt); sockopt = NULL; return SERVICE_FAILURE,
+        "Failed to parse socket family");
+    ret = ParseSocketType(json, sockopt);
+    INIT_ERROR_CHECK(ret == 0, free(sockopt); sockopt = NULL; return SERVICE_FAILURE,
+        "Failed to parse socket type");
+    ret = ParseSocketProtocol(json, sockopt);
+    INIT_ERROR_CHECK(ret == 0, free(sockopt); sockopt = NULL; return SERVICE_FAILURE,
+        "Failed to parse socket protocol");
+
+    char *stringValue = GetStringValue(json, "permissions", &strLen);
+    INIT_ERROR_CHECK((stringValue != NULL) && (strLen > 0), free(sockopt); sockopt = NULL; return SERVICE_FAILURE,
+        "Failed to get string for permissions");
+    sockopt->perm = strtoul(stringValue, 0, OCTAL_BASE);
+    stringValue = GetStringValue(json, "uid", &strLen);
+    INIT_ERROR_CHECK((stringValue != NULL) && (strLen > 0), free(sockopt); sockopt = NULL; return SERVICE_FAILURE,
+        "Failed to get string for uid");
+    sockopt->uid = DecodeUid(stringValue);
+    stringValue = GetStringValue(json, "gid", &strLen);
+    INIT_ERROR_CHECK((stringValue != NULL) && (strLen > 0), free(sockopt); sockopt = NULL; return SERVICE_FAILURE,
+        "Failed to get string for gid");
+    sockopt->gid = DecodeUid(stringValue);
+    INIT_ERROR_CHECK((sockopt->uid != (uid_t)-1) && (sockopt->gid != (uid_t)-1),
+        free(sockopt); sockopt = NULL; return SERVICE_FAILURE, "Invalid uid or gid");
+    ret = ParseSocketOption(json, sockopt);
+    INIT_ERROR_CHECK(ret == 0, free(sockopt); sockopt = NULL; return SERVICE_FAILURE,
+        "Failed to parse socket option");
+
     sockopt->next = NULL;
     if (service->socketCfg == NULL) {
         service->socketCfg = sockopt;

services/init/init_service_socket.c

@@ -21,12 +21,12 @@
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/uio.h>
-#include <sys/un.h>
 
 #include "init_log.h"
 #include "init_service.h"
 #include "loop_event.h"
 #include "securec.h"
+#define SOCKET_BUFF_SIZE (256 * 1024)
 
 #define HOS_SOCKET_DIR "/dev/unix/socket"
 #define HOS_SOCKET_ENV_PREFIX "OHOS_SOCKET_"
@@ -43,49 +43,99 @@ static int GetSocketAddr(struct sockaddr_un *addr, const char *name)
     return 0;
 }
 
-static int CreateSocket(ServiceSocket *sockopt)
+static int SetSocketAddr(ServiceSocket *sockopt, sockaddr_union *addr)
 {
-    INIT_ERROR_CHECK(sockopt != NULL, return SERVICE_FAILURE, "Invalid socket opt");
-    if (sockopt->sockFd >= 0) {
-        close(sockopt->sockFd);
-        sockopt->sockFd = -1;
+    int ret = 0;
+    if (sockopt->family == AF_NETLINK) {
+#ifndef __LITEOS__
+        if (memset_s(&(addr->addrnl), sizeof(addr->addrnl), 0, sizeof(addr->addrnl)) != EOK) {
+            INIT_LOGE("Faild to clear socket address");
+            return -1;
+        }
+        addr->addrnl.nl_family = AF_NETLINK;
+        addr->addrnl.nl_pid = getpid();
+        addr->addrnl.nl_groups = 0xffffffff;
+#else
+        INIT_LOGE("No support in liteos kernel");
+        return -1;
+#endif
+    } else {
+        ret = GetSocketAddr(&(addr->addrun), sockopt->name);
+        INIT_ERROR_CHECK(ret == 0, return -1, "Failed to format addr %s", sockopt->name);
+        if (access(addr->addrun.sun_path, F_OK) == 0) {
+            INIT_LOGI("%s already exist, remove it", addr->addrun.sun_path);
+            unlink(addr->addrun.sun_path);
+        }
     }
-    sockopt->sockFd = socket(PF_UNIX, sockopt->type, 0);
-    INIT_ERROR_CHECK(sockopt->sockFd >= 0, return -1, "socket fail %d ", errno);
-
-    struct sockaddr_un addr;
-    int ret = GetSocketAddr(&addr, sockopt->name);
-    INIT_ERROR_CHECK(ret == 0, return -1, "Failed to format addr %s", sockopt->name);
+    return ret;
+}
 
-    do {
-        ret = -1;
-        if (access(addr.sun_path, F_OK) == 0) {
-            INIT_LOGI("%s already exist, remove it", addr.sun_path);
-            unlink(addr.sun_path);
+static int SetSocketOptionAndBind(ServiceSocket *sockopt)
+{
+    if (sockopt->option & SOCKET_OPTION_PASSCRED) {
+        int on = 1;
+        if (setsockopt(sockopt->sockFd, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on))) {
+            INIT_LOGE("Failed to setsockopt");
+            return -1;
         }
-        if (sockopt->passcred) {
-            int on = 1;
-            if (setsockopt(sockopt->sockFd, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on))) {
-                break;
-            }
+    }
+    if (sockopt->option & SOCKET_OPTION_RCVBUFFORCE) {
+        int buffSize = SOCKET_BUFF_SIZE;
+        if (setsockopt(sockopt->sockFd, SOL_SOCKET, SO_RCVBUFFORCE, &buffSize, sizeof(buffSize))) {
+            INIT_LOGE("Failed to setsockopt");
+            return -1;
+        }
+    }
+    sockaddr_union addr = {};
+    if (SetSocketAddr(sockopt, &addr) != 0) {
+        INIT_LOGE("Failed to set socket addr");
+        return -1;
+    }
+    if (sockopt->family == AF_NETLINK) {
+#ifndef __LITEOS__
+        if (bind(sockopt->sockFd, (struct sockaddr *)&(addr.addrnl), sizeof(addr.addrnl))) {
+            INIT_LOGE("Create socket for service %s failed: %d", sockopt->name, errno);
+            return -1;
         }
-        if (bind(sockopt->sockFd, (struct sockaddr *)&addr, sizeof(addr))) {
+#else
+        INIT_LOGE("No support in liteos kernel");
+        return -1;
+#endif
+    } else {
+        if (bind(sockopt->sockFd, (struct sockaddr *)&(addr.addrun), sizeof(addr.addrun))) {
             INIT_LOGE("Create socket for service %s failed: %d", sockopt->name, errno);
-            break;
+            return -1;
         }
-        if (lchown(addr.sun_path, sockopt->uid, sockopt->gid)) {
+        if (lchown(addr.addrun.sun_path, sockopt->uid, sockopt->gid)) {
             INIT_LOGE("lchown fail %d ", errno);
-            break;
+            unlink(addr.addrun.sun_path);
+            return -1;
         }
-        if (fchmodat(AT_FDCWD, addr.sun_path, sockopt->perm, AT_SYMLINK_NOFOLLOW)) {
+        if (fchmodat(AT_FDCWD, addr.addrun.sun_path, sockopt->perm, AT_SYMLINK_NOFOLLOW)) {
             INIT_LOGE("fchmodat fail %d ", errno);
-            break;
+            unlink(addr.addrun.sun_path);
+            return -1;
         }
-        ret = 0;
-    } while (0);
+    }
+    return 0;
+}
+
+static int CreateSocket(ServiceSocket *sockopt)
+{
+    INIT_ERROR_CHECK(sockopt != NULL, return SERVICE_FAILURE, "Invalid socket opt");
+    INIT_LOGI("name: %s, family: %d, type: %u, protocol: %d, perm: %u, uid: %u, gid: %u, option: %u",
+        sockopt->name, sockopt->family, sockopt->type, sockopt->protocol,
+        sockopt->perm, sockopt->uid,    sockopt->gid,  sockopt->option);
+    if (sockopt->sockFd >= 0) {
+        close(sockopt->sockFd);
+        sockopt->sockFd = -1;
+    }
+    sockopt->sockFd = socket(sockopt->family, sockopt->type, sockopt->protocol);
+    INIT_ERROR_CHECK(sockopt->sockFd >= 0, return -1, "socket fail %d ", errno);
+
+    int ret = SetSocketOptionAndBind(sockopt);
     if (ret != 0) {
         close(sockopt->sockFd);
-        unlink(addr.sun_path);
         return -1;
     }
     INIT_LOGI("CreateSocket %s success", sockopt->name);
@@ -162,8 +212,10 @@ int CreateServiceSocket(Service *service)
                 ret = listen(tmpSock->sockFd, MAX_SOCKET_FD_LEN);
                 INIT_CHECK_RETURN_VALUE(ret == 0, -1);
             }
-            ret = SocketAddWatcher(&tmpSock->watcher, service, tmpSock->sockFd);
-            INIT_CHECK_RETURN_VALUE(ret == 0, -1);
+            if (strcmp(service->name, "ueventd") != 0) {
+                ret = SocketAddWatcher(&tmpSock->watcher, service, tmpSock->sockFd);
+                INIT_CHECK_RETURN_VALUE(ret == 0, -1);
+            }
         }
         ret = SetSocketEnv(fd, tmpSock->name);
         INIT_CHECK_RETURN_VALUE(ret >= 0, -1);

services/init/lite/init_service.c

@@ -67,7 +67,14 @@ int ServiceExec(const Service *service)
     INIT_ERROR_CHECK(service != NULL && service->pathArgs.count > 0,
         return SERVICE_FAILURE, "Exec service failed! null ptr.");
     INIT_LOGI("service->name is %s ", service->name);
-    char *env[] = { "LD_LIBRARY_PATH=/storage/app/libs", NULL };
+    char *env[] = { "LD_LIBRARY_PATH=/storage/app/libs", NULL, NULL };
+    char sockEnv[MAX_ENV_NAME] = {0};
+    if (service->socketCfg != NULL) {
+        INIT_ERROR_CHECK(snprintf_s(sockEnv, sizeof(sockEnv), sizeof(sockEnv) - 1, "OHOS_SOCKET_%s=%d",
+            service->socketCfg->name, service->socketCfg->sockFd) != -1,
+            return SERVICE_FAILURE, "format socket env failed!");
+        env[1] = sockEnv;
+    }
     if (execve(service->pathArgs.argv[0], service->pathArgs.argv, env) != 0) {
         INIT_LOGE("service %s execve failed! err %d.", service->name, errno);
         return errno;

test/unittest/common/BUILD.gn

@@ -22,7 +22,10 @@ if (defined(ohos_lite)) {
       "-lpthread",
       "-lm",
     ]
-    defines = [ "OHOS_LITE" ]
+    defines = [
+      "OHOS_LITE",
+      "__MUSL__",
+    ]
     if (storage_type == "emmc") {
       defines += [ "USE_EMMC_STORAGE" ]
     }

test/unittest/init/service_socket_unittest.cpp

@@ -42,7 +42,7 @@ HWTEST_F(ServiceSocketUnitTest, TestCreateSocket, TestSize.Level0)
     sockopt->uid = 1000;
     sockopt->gid = 1000;
     sockopt->perm = 0660;
-    sockopt->passcred = true;
+    sockopt->option = SOCKET_OPTION_PASSCRED;
     const char *testSocName = "test_socket";
     errno_t ret = strncpy_s(sockopt->name, strlen(testSocName) + 1, testSocName, strlen(testSocName));
     sockopt->next = NULL;

ueventd/BUILD.gn

@@ -17,11 +17,11 @@ if (defined(ohos_lite)) {
       sources = [
         "//base/startup/init_lite/services/utils/init_utils.c",
         "//base/startup/init_lite/services/utils/list.c",
+        "//base/startup/init_lite/ueventd/lite/ueventd_main.c",
         "//base/startup/init_lite/ueventd/lite/ueventd_parameter.c",
         "//base/startup/init_lite/ueventd/ueventd.c",
         "//base/startup/init_lite/ueventd/ueventd_device_handler.c",
         "//base/startup/init_lite/ueventd/ueventd_firmware_handler.c",
-        "//base/startup/init_lite/ueventd/ueventd_main.c",
         "//base/startup/init_lite/ueventd/ueventd_read_cfg.c",
         "//base/startup/init_lite/ueventd/ueventd_socket.c",
       ]
@@ -39,6 +39,7 @@ if (defined(ohos_lite)) {
       ]
 
       deps = [
+        "//base/startup/init_lite/interfaces/innerkits/socket:libsocket_static",
         "//base/startup/init_lite/services/log:init_log",
         "//third_party/bounds_checking_function:libsec_static",
       ]
@@ -80,6 +81,7 @@ if (defined(ohos_lite)) {
   ]
 
   service_ueventd_deps = [
+    "//base/startup/init_lite/interfaces/innerkits/socket:libsocket_static",
     "//base/startup/init_lite/services/log:init_log",
     "//base/startup/init_lite/services/utils:libinit_utils",
     "//third_party/bounds_checking_function:libsec_static",
@@ -102,11 +104,14 @@ if (defined(ohos_lite)) {
   ohos_executable("ueventd") {
     sources = service_ueventd_sources
     sources += [
+      "//base/startup/init_lite/ueventd/standard/ueventd_main.c",
       "//base/startup/init_lite/ueventd/standard/ueventd_parameter.c",
-      "//base/startup/init_lite/ueventd/ueventd_main.c",
     ]
     include_dirs = service_ueventd_include
-    include_dirs += [ "//base/startup/init_lite/services/include/param" ]
+    include_dirs += [
+      "//base/startup/init_lite/services/include/param",
+      "//base/startup/init_lite/interfaces/innerkits/include",
+    ]
     deps = service_ueventd_deps
     deps += [ "//base/startup/init_lite/services/param:param_client" ]
     install_images = [

ueventd/include/ueventd.h

@@ -61,6 +61,8 @@ typedef enum SUBYSTEM {
 } SUBSYSTEMTYPE;
 
 #define CMDLINE_VALUE_LEN_MAX 512
+#define UEVENTD_POLL_TIME 30000
+#define UEVENTD_FLAG "/dev/.ueventd_trigger_done"
 
 extern char bootDevice[CMDLINE_VALUE_LEN_MAX];
 

ueventd/standard/ueventd_main.c

+/*
+ * Copyright (c) 2021 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
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <poll.h>
+#include "ueventd.h"
+#include "ueventd_read_cfg.h"
+#include "ueventd_socket.h"
+#define INIT_LOG_TAG "ueventd"
+#include "init_log.h"
+#include "init_socket.h"
+
+int main(int argc, char **argv)
+{
+    char *ueventdConfigs[] = {"/etc/ueventd.config", NULL};
+    int i = 0;
+    int ret = -1;
+    while (ueventdConfigs[i] != NULL) {
+        ParseUeventdConfigFile(ueventdConfigs[i++]);
+    }
+    int ueventSockFd = GetControlSocket("ueventd");
+    if (ueventSockFd < 0) {
+        INIT_LOGW("Failed to get uevent socket, try to create");
+        ueventSockFd = UeventdSocketInit();
+    }
+    if (ueventSockFd < 0) {
+        INIT_LOGE("Failed to create uevent socket!");
+        return -1;
+    }
+    if (access(UEVENTD_FLAG, F_OK)) {
+        INIT_LOGI("ueventd first start to trigger");
+        RetriggerUevent(ueventSockFd, NULL, 0); // Not require boot devices
+        struct pollfd pfd = {};
+        pfd.events = POLLIN;
+        pfd.fd = ueventSockFd;
+
+        while (1) {
+            pfd.revents = 0;
+            ret = poll(&pfd, 1, UEVENTD_POLL_TIME);
+            if (ret == 0) {
+                break;
+            } else if (ret < 0) {
+                INIT_LOGE("Failed to poll ueventd socket!");
+                return -1;
+            }
+            if (pfd.revents & POLLIN) {
+                ProcessUevent(ueventSockFd, NULL, 0); // Not require boot devices
+            }
+        }
+        int fd = open(UEVENTD_FLAG, O_RDWR | O_CREAT);
+        if (fd < 0) {
+            INIT_LOGE("Failed to create ueventd flag!");
+            return -1;
+        }
+        (void)close(fd);
+    } else {
+        INIT_LOGI("ueventd start to process uevent message");
+        ProcessUevent(ueventSockFd, NULL, 0); // Not require boot devices
+    }
+    return 0;
+}

ueventd/ueventd_device_handler.c

@@ -331,7 +331,7 @@ static void HandleDeviceNode(const struct Uevent *uevent, const char *deviceNode
 #endif
         }
     } else if (action == ACTION_CHANGE) {
-        INIT_LOGI("Device %s changed", uevent->syspath);
+        INIT_LOGV("Device %s changed", uevent->syspath);
     }
     // Ignore other actions
     FreeSymbolLinks(symLinks);

watchdog/init_watchdog.c

@@ -33,9 +33,10 @@
 
 #include "init_log.h"
 
-#define WAIT_MAX_COUNT 10
+#define WAIT_MAX_COUNT 20
 #define DEFAULT_INTERVAL 3
 #define DEFAULT_GAP 3
+#define CONVERSION_BASE 1000000U
 
 static void WaitAtStartup(const char *source)
 {
@@ -47,7 +48,7 @@ static void WaitAtStartup(const char *source)
         count++;
     } while ((stat(source, &sourceInfo) < 0) && (errno == ENOENT) && (count < WAIT_MAX_COUNT));
     if (count == WAIT_MAX_COUNT) {
-        INIT_LOGE("wait for file:%s failed after %f.", source, WAIT_MAX_COUNT>>1);
+        INIT_LOGE("wait for file:%s failed after %u seconds.", source, (WAIT_MAX_COUNT * waitTime) / CONVERSION_BASE);
     }
     return;
 }