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