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 "init_service_socket.h"
16 
17 #include <errno.h>
18 #include <fcntl.h>
19 #include <netinet/in.h>
20 #include <string.h>
21 #include <sys/socket.h>
22 #include <sys/stat.h>
23 #include <sys/uio.h>
24 
25 #include "init_cmdexecutor.h"
26 #include "init_log.h"
27 #include "init_service.h"
28 #include "loop_event.h"
29 #include "securec.h"
30 #include "init_group_manager.h"
31 #define SOCKET_BUFF_SIZE (256 * 1024)
32 
33 #define HOS_SOCKET_DIR "/dev/unix/socket"
34 #define HOS_SOCKET_PATH 64
35 #define HOS_SOCKET_ENV_PREFIX "OHOS_SOCKET_"
36 #define MAX_SOCKET_ENV_PREFIX_LEN 64
37 #define MAX_SOCKET_FD_LEN 16
38 
GetSocketAddr(struct sockaddr_un * addr,const char * name)39 static int GetSocketAddr(struct sockaddr_un *addr, const char *name)
40 {
41     (void)memset_s(addr, sizeof(struct sockaddr_un), 0x0, sizeof(struct sockaddr_un));
42     addr->sun_family = AF_UNIX;
43     size_t addrLen = sizeof(addr->sun_path);
44     int ret = snprintf_s(addr->sun_path, addrLen, addrLen - 1, HOS_SOCKET_DIR "/%s", name);
45     INIT_ERROR_CHECK(ret >= 0, return -1, "Failed to format addr %s", name);
46     return 0;
47 }
48 
SetSocketAddr(ServiceSocket * sockopt,sockaddr_union * addr)49 static int SetSocketAddr(ServiceSocket *sockopt, sockaddr_union *addr)
50 {
51     int ret = 0;
52     if (sockopt->family == AF_NETLINK) {
53 #ifndef __LITEOS_A__
54         if (memset_s(&(addr->addrnl), sizeof(addr->addrnl), 0, sizeof(addr->addrnl)) != EOK) {
55             INIT_LOGE("Failed to clear socket address");
56             return -1;
57         }
58         addr->addrnl.nl_family = AF_NETLINK;
59         addr->addrnl.nl_pid = getpid();
60         addr->addrnl.nl_groups = 0xffffffff;
61 #else
62         INIT_LOGE("No support in liteos kernel");
63         return -1;
64 #endif
65     } else {
66         ret = GetSocketAddr(&(addr->addrun), sockopt->name);
67         INIT_ERROR_CHECK(ret == 0, return -1, "Failed to format addr %s", sockopt->name);
68         if (access(addr->addrun.sun_path, F_OK) == 0) {
69             INIT_LOGI("%s already exist, remove it", addr->addrun.sun_path);
70             unlink(addr->addrun.sun_path);
71         }
72     }
73     return ret;
74 }
75 
SetSocketOptionAndBind(ServiceSocket * sockopt)76 static int SetSocketOptionAndBind(ServiceSocket *sockopt)
77 {
78     if (sockopt->option & SOCKET_OPTION_PASSCRED) {
79         int on = 1;
80         if (setsockopt(sockopt->sockFd, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on))) {
81             INIT_LOGE("Failed to setsockopt");
82             return -1;
83         }
84     }
85     if (sockopt->option & SOCKET_OPTION_RCVBUFFORCE) {
86         int buffSize = SOCKET_BUFF_SIZE;
87         if (setsockopt(sockopt->sockFd, SOL_SOCKET, SO_RCVBUFFORCE, &buffSize, sizeof(buffSize))) {
88             INIT_LOGE("Failed to setsockopt");
89             return -1;
90         }
91     }
92     sockaddr_union addr = {};
93     if (SetSocketAddr(sockopt, &addr) != 0) {
94         INIT_LOGE("Failed to set socket addr");
95         return -1;
96     }
97     if (sockopt->family == AF_NETLINK) {
98 #ifndef __LITEOS_A__
99         if (bind(sockopt->sockFd, (struct sockaddr *)&(addr.addrnl), sizeof(addr.addrnl))) {
100             INIT_LOGE("Create socket for service %s failed: %d", sockopt->name, errno);
101             return -1;
102         }
103 #else
104         INIT_LOGE("No support in liteos kernel");
105         return -1;
106 #endif
107     } else {
108         if (bind(sockopt->sockFd, (struct sockaddr *)&(addr.addrun), sizeof(addr.addrun))) {
109             INIT_LOGE("Create socket for service %s failed: %d", sockopt->name, errno);
110             return -1;
111         }
112         if (lchown(addr.addrun.sun_path, sockopt->uid, sockopt->gid)) {
113             INIT_LOGE("lchown fail %d ", errno);
114             unlink(addr.addrun.sun_path);
115             return -1;
116         }
117         if (fchmodat(AT_FDCWD, addr.addrun.sun_path, sockopt->perm, AT_SYMLINK_NOFOLLOW)) {
118             INIT_LOGE("fchmodat fail %d ", errno);
119             unlink(addr.addrun.sun_path);
120             return -1;
121         }
122     }
123     return 0;
124 }
125 
CreateSocket(ServiceSocket * sockopt)126 static int CreateSocket(ServiceSocket *sockopt)
127 {
128     INIT_ERROR_CHECK(sockopt != NULL, return SERVICE_FAILURE, "Invalid socket options");
129     INIT_LOGV("Socket name: %s, family: %d, type: %u, protocol: %d, perm: %u, uid: %u, gid: %u, option: %u",
130         sockopt->name, sockopt->family, sockopt->type, sockopt->protocol,
131         sockopt->perm, sockopt->uid,    sockopt->gid,  sockopt->option);
132     if (sockopt->sockFd >= 0) {
133         close(sockopt->sockFd);
134         sockopt->sockFd = -1;
135     }
136     sockopt->sockFd = socket(sockopt->family, sockopt->type, sockopt->protocol);
137     INIT_ERROR_CHECK(sockopt->sockFd >= 0, return -1, "socket fail %d ", errno);
138 
139     int ret = SetSocketOptionAndBind(sockopt);
140     if (ret != 0) {
141         close(sockopt->sockFd);
142         return -1;
143     }
144     INIT_LOGI("CreateSocket %s success", sockopt->name);
145 
146     char path[HOS_SOCKET_PATH] = { 0 };
147     if (snprintf_s(path, sizeof(path), sizeof(path) - 1, HOS_SOCKET_DIR"/%s", sockopt->name) < 0) {
148         close(sockopt->sockFd);
149         return -1;
150     }
151     PluginExecCmdByName("restoreContentRecurse", path);
152     INIT_LOGI("CreateSocket restoreContentRecurse %s success", path);
153     return sockopt->sockFd;
154 }
155 
ProcessWatchEvent_(const WatcherHandle watcherHandle,int fd,uint32_t * events,const void * context)156 static void ProcessWatchEvent_(const WatcherHandle watcherHandle, int fd, uint32_t *events, const void *context)
157 {
158     *events = 0;
159     Service *service = (Service *)context;
160     ServiceSocket *tmpSock = service->socketCfg;
161     while (tmpSock != NULL) {
162         if (tmpSock->sockFd == fd) {
163             tmpSock->watcher = NULL;
164             break;
165         }
166         tmpSock = tmpSock->next;
167     }
168     if (tmpSock == NULL) { // not found socket
169         INIT_LOGE("Service %s not match socket fd %d!", service->name, fd);
170         close(fd);
171         return;
172     }
173     INIT_LOGI("Socket information detected, fd:%d service name:%s", fd, service->name);
174     RemoveSocketWatcher(watcherHandle);
175     if (ServiceStart(service, &service->pathArgs) != SERVICE_SUCCESS) {
176         INIT_LOGE("Service %s start failed!", service->name);
177     }
178 }
179 
AddSocketWatcher(ServiceWatcher * watcherHandle,Service * service,int fd)180 int AddSocketWatcher(ServiceWatcher *watcherHandle, Service *service, int fd)
181 {
182     WatcherHandle handle;
183     LE_WatchInfo info = {};
184     info.fd = fd;
185     info.flags = WATCHER_ONCE;
186     info.events = EVENT_READ;
187     info.processEvent = ProcessWatchEvent_;
188     int ret = LE_StartWatcher(LE_GetDefaultLoop(), &handle, &info, service);
189     INIT_LOGI("Watcher socket fd %d for service %s", fd, service->name);
190     *watcherHandle = (ServiceWatcher)handle;
191     return ret;
192 }
193 
RemoveSocketWatcher(ServiceWatcher watcherHandle)194 void RemoveSocketWatcher(ServiceWatcher watcherHandle)
195 {
196     LE_RemoveWatcher(LE_GetDefaultLoop(), (WatcherHandle)watcherHandle);
197 }
198 
CreateSocketForService(Service * service)199 int CreateSocketForService(Service *service)
200 {
201     INIT_CHECK(service != NULL && service->socketCfg != NULL, return 0);
202     INIT_CHECK(service->socketCfg->sockFd == -1, return 0);
203     int ret = 0;
204     ServiceSocket *tmpSock = service->socketCfg;
205     // insert OnDemand service socket head node to InitWorkspace socketNode head node
206     if (tmpSock != NULL && IsOnDemandService(service)) {
207         AddOnDemandSocket(tmpSock);
208     }
209     while (tmpSock != NULL) {
210         PluginExecCmdByName("setSockCreateCon", service->name);
211         int fd = CreateSocket(tmpSock);
212         PluginExecCmdByName("setSockCreateCon", "");
213         INIT_CHECK_RETURN_VALUE(fd >= 0, -1);
214         if (IsOnDemandService(service)) {
215             if (IsConnectionBasedSocket(tmpSock)) {
216                 ret = listen(tmpSock->sockFd, MAX_SOCKET_FD_LEN);
217                 INIT_CHECK_RETURN_VALUE(ret == 0, -1);
218             }
219             if (strcmp(service->name, "ueventd") != 0) {
220                 ret = AddSocketWatcher(&tmpSock->watcher, service, tmpSock->sockFd);
221                 INIT_CHECK_RETURN_VALUE(ret == 0, -1);
222             }
223         }
224         tmpSock = tmpSock->next;
225     }
226     return 0;
227 }
228 
SetSocketEnvForService(Service * service)229 int SetSocketEnvForService(Service *service)
230 {
231     INIT_ERROR_CHECK(service != NULL, return SERVICE_FAILURE, "Invalid name");
232     char pubName[MAX_SOCKET_ENV_PREFIX_LEN] = { 0 };
233     char val[MAX_SOCKET_FD_LEN] = { 0 };
234 
235     ServiceSocket *tmpSock = service->socketCfg;
236 
237     while (tmpSock != NULL) {
238         INIT_CHECK_RETURN_VALUE(snprintf_s(pubName, sizeof(pubName), sizeof(pubName) - 1, HOS_SOCKET_ENV_PREFIX "%s",
239             tmpSock->name) >= 0, -1);
240         INIT_CHECK_RETURN_VALUE(snprintf_s(val, sizeof(val), sizeof(val) - 1, "%d", tmpSock->sockFd) >= 0, -1);
241 
242         int ret = setenv(pubName, val, 1);
243         INIT_ERROR_CHECK(ret >= 0, continue, "setenv:%s fail %d ", tmpSock->name, errno);
244         fcntl(tmpSock->sockFd, F_SETFD, 0);
245 
246         tmpSock = tmpSock->next;
247     }
248 
249     return 0;
250 }
251 
CloseServiceSocket(Service * service)252 void CloseServiceSocket(Service *service)
253 {
254     INIT_CHECK(service != NULL && service->socketCfg != NULL, return);
255     struct sockaddr_un addr;
256     ServiceSocket *sockopt = service->socketCfg;
257     while (sockopt != NULL) {
258         if (sockopt->watcher != NULL) {
259             RemoveSocketWatcher(sockopt->watcher);
260         }
261         if (sockopt->sockFd >= 0) {
262             close(sockopt->sockFd);
263             sockopt->sockFd = -1;
264         }
265         if (GetSocketAddr(&addr, sockopt->name) == 0) {
266 #ifndef STARTUP_INIT_TEST
267             unlink(addr.sun_path);
268 #endif
269         }
270         sockopt = sockopt->next;
271     }
272     return;
273 }
274