1 /*
2 * Copyright (C) 2018-2022 Intel Corporation.
3 * SPDX-License-Identifier: BSD-3-Clause
4 */
5
6 /*
7 * Copyright (C) 2018-2022 Intel Corporation.
8 *
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 * http://www.apache.org/licenses/LICENSE-2.0
14 *
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 */
21
22 #include <stddef.h>
23 #include <errno.h>
24 #include <stdbool.h>
25 #include <string.h>
26
27 #include "protocol.h"
28 #include "log_sys.h"
29
30 #define SUN_PATH_MAX \
31 (sizeof(struct sockaddr_un) - offsetof(struct sockaddr_un, sun_path))
32
33 /* Documented in header file. */
socket_make_sockaddr_un(const char * name,const size_t len,struct sockaddr_un * p_addr,socklen_t * alen)34 static int socket_make_sockaddr_un(const char *name, const size_t len,
35 struct sockaddr_un *p_addr, socklen_t *alen)
36 {
37 size_t socket_len;
38
39 socket_len = strlen(RESERVED_SOCKET_PREFIX);
40 if (socket_len >= SUN_PATH_MAX)
41 return -1;
42 strncpy(p_addr->sun_path, RESERVED_SOCKET_PREFIX, socket_len + 1);
43 if (len >= (SUN_PATH_MAX - socket_len))
44 return -1;
45 strncat(p_addr->sun_path, name, len);
46
47 p_addr->sun_family = AF_LOCAL;
48 *alen = len + socket_len +
49 offsetof(struct sockaddr_un, sun_path) + 1;
50 return 0;
51 }
52
53 /**
54 * connect to peer named "name" on fd
55 * returns same fd or -1 on error.
56 * fd is not closed on error. that's your job.
57 *
58 */
socket_local_client_connect(int fd,const char * name,const size_t len)59 static int socket_local_client_connect(int fd, const char *name,
60 const size_t len)
61 {
62 struct sockaddr_un addr;
63 socklen_t alen;
64 int err;
65
66 err = socket_make_sockaddr_un(name, len, &addr, &alen);
67
68 if (err < 0)
69 goto error;
70
71 if (connect(fd, (struct sockaddr *) &addr, alen) < 0) {
72 LOGE("connect to usercrashd failed ,error (%s)\n",
73 strerror(errno));
74 goto error;
75 }
76
77 return fd;
78
79 error:
80 return -1;
81 }
82
83 /**
84 * connect to peer named "name"
85 * returns fd or -1 on error
86 */
socket_local_client(const char * name,const size_t len,int type)87 int socket_local_client(const char *name, const size_t len, int type)
88 {
89 int s;
90
91 s = socket(AF_LOCAL, type, 0);
92 if (s < 0)
93 return -1;
94
95 if (socket_local_client_connect(s, name, len) < 0) {
96 close(s);
97 return -1;
98 }
99
100 return s;
101 }
102
socket_bind(int fd,const char * name)103 static int socket_bind(int fd, const char *name)
104 {
105 struct sockaddr_un addr;
106 socklen_t alen;
107 size_t name_len;
108
109 addr.sun_family = AF_UNIX;
110 name_len = strnlen(name, SOCKET_PATH_MAX);
111 if (name_len >= SUN_PATH_MAX)
112 return -1;
113 *(char *)mempcpy(addr.sun_path, name, name_len) = '\0';
114 unlink(addr.sun_path);
115 alen = strnlen(addr.sun_path, SUN_PATH_MAX) + sizeof(addr.sun_family);
116
117 if (bind(fd, (struct sockaddr *)&addr, alen) == -1)
118 return -1;
119
120 return fd;
121 }
122
create_socket_server(const char * name,int type)123 int create_socket_server(const char *name, int type)
124 {
125 int err;
126 int fd;
127
128 fd = socket(AF_UNIX, type, 0);
129 if (fd < 0)
130 return -1;
131
132 err = socket_bind(fd, name);
133
134 if (err < 0) {
135 close(fd);
136 return -1;
137 }
138
139 return fd;
140 }
141
send_fd(int sockfd,const void * data,size_t len,int fd)142 ssize_t send_fd(int sockfd, const void *data, size_t len, int fd)
143 {
144 char cmsg_buf[CMSG_SPACE(sizeof(int))];
145 struct msghdr msg;
146 struct iovec iov;
147 struct cmsghdr *cmsg;
148
149 memset(&iov, 0, sizeof(iov));
150 iov.iov_base = (void *)data;
151 iov.iov_len = len;
152 memset(&msg, 0, sizeof(msg));
153 msg.msg_iov = &iov;
154 msg.msg_iovlen = 1;
155 msg.msg_control = cmsg_buf;
156 msg.msg_controllen = sizeof(cmsg_buf);
157
158 cmsg = CMSG_FIRSTHDR(&msg);
159 cmsg->cmsg_level = SOL_SOCKET;
160 cmsg->cmsg_type = SCM_RIGHTS;
161 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
162 *(int *)(CMSG_DATA(cmsg)) = fd;
163
164 return sendmsg(sockfd, &msg, 0);
165 }
166
recv_fd(int sockfd,void * data,size_t len,int * out_fd)167 ssize_t recv_fd(int sockfd, void *data, size_t len, int *out_fd)
168 {
169 char cmsg_buf[CMSG_SPACE(sizeof(int))];
170 struct msghdr msg;
171 struct iovec iov;
172 struct cmsghdr *cmsg;
173 ssize_t result;
174 bool received_fd;
175 int fd;
176
177 memset(&iov, 0, sizeof(iov));
178 iov.iov_base = (void *)data;
179 iov.iov_len = len;
180 memset(&msg, 0, sizeof(msg));
181 msg.msg_iov = &iov;
182 msg.msg_iovlen = 1;
183 msg.msg_control = cmsg_buf;
184 msg.msg_controllen = sizeof(cmsg_buf);
185 msg.msg_flags = 0;
186
187 cmsg = CMSG_FIRSTHDR(&msg);
188 cmsg->cmsg_level = SOL_SOCKET;
189 cmsg->cmsg_type = SCM_RIGHTS;
190 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
191
192 result = recvmsg(sockfd, &msg, 0);
193 if (result == -1)
194 return -1;
195
196 received_fd = msg.msg_controllen == sizeof(cmsg_buf);
197 if (received_fd)
198 fd = *(int *)(CMSG_DATA(cmsg));
199 else
200 return -1;
201
202 if ((msg.msg_flags & MSG_TRUNC) != 0) {
203 errno = EFBIG;
204 goto fail;
205 } else if ((msg.msg_flags & MSG_CTRUNC) != 0) {
206 errno = ERANGE;
207 goto fail;
208 }
209
210 if (out_fd) {
211 *out_fd = fd;
212 } else if (received_fd) {
213 errno = ERANGE;
214 goto fail;
215 }
216
217 return result;
218 fail:
219 close(fd);
220 return -1;
221 }
222