Line data Source code
1 : /* SPDX-License-Identifier: LGPL-2.1+
2 : *
3 : * libudev - interface to udev device information
4 : *
5 : * This library is free software; you can redistribute it and/or
6 : * modify it under the terms of the GNU Lesser General Public
7 : * License as published by the Free Software Foundation; either
8 : * version 2.1 of the License, or (at your option) any later version.
9 : */
10 :
11 : #include <errno.h>
12 : #include <poll.h>
13 : #include <stddef.h>
14 : #include <stdlib.h>
15 : #include <string.h>
16 : #include <sys/socket.h>
17 : #include <sys/un.h>
18 : #include <unistd.h>
19 :
20 : #include "sd-event.h"
21 :
22 : #include "alloc-util.h"
23 : #include "errno-util.h"
24 : #include "fd-util.h"
25 : #include "format-util.h"
26 : #include "io-util.h"
27 : #include "socket-util.h"
28 : #include "strxcpyx.h"
29 : #include "udev-ctrl.h"
30 : #include "util.h"
31 :
32 : /* wire protocol magic must match */
33 : #define UDEV_CTRL_MAGIC 0xdead1dea
34 :
35 : struct udev_ctrl_msg_wire {
36 : char version[16];
37 : unsigned magic;
38 : enum udev_ctrl_msg_type type;
39 : union udev_ctrl_msg_value value;
40 : };
41 :
42 : struct udev_ctrl {
43 : unsigned n_ref;
44 : int sock;
45 : int sock_connect;
46 : union sockaddr_union saddr;
47 : socklen_t addrlen;
48 : bool bound:1;
49 : bool cleanup_socket:1;
50 : bool connected:1;
51 : bool maybe_disconnected:1;
52 : sd_event *event;
53 : sd_event_source *event_source;
54 : sd_event_source *event_source_connect;
55 : udev_ctrl_handler_t callback;
56 : void *userdata;
57 : };
58 :
59 0 : int udev_ctrl_new_from_fd(struct udev_ctrl **ret, int fd) {
60 0 : _cleanup_close_ int sock = -1;
61 : struct udev_ctrl *uctrl;
62 : int r;
63 :
64 0 : assert(ret);
65 :
66 0 : if (fd < 0) {
67 0 : sock = socket(AF_LOCAL, SOCK_SEQPACKET|SOCK_NONBLOCK|SOCK_CLOEXEC, 0);
68 0 : if (sock < 0)
69 0 : return log_error_errno(errno, "Failed to create socket: %m");
70 : }
71 :
72 0 : uctrl = new(struct udev_ctrl, 1);
73 0 : if (!uctrl)
74 0 : return -ENOMEM;
75 :
76 0 : *uctrl = (struct udev_ctrl) {
77 : .n_ref = 1,
78 0 : .sock = fd >= 0 ? fd : TAKE_FD(sock),
79 0 : .bound = fd >= 0,
80 : };
81 :
82 : /*
83 : * FIXME: remove it as soon as we can depend on this:
84 : * http://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=90c6bd34f884cd9cee21f1d152baf6c18bcac949
85 : */
86 0 : r = setsockopt_int(uctrl->sock, SOL_SOCKET, SO_PASSCRED, true);
87 0 : if (r < 0)
88 0 : log_warning_errno(r, "Failed to set SO_PASSCRED: %m");
89 :
90 0 : uctrl->saddr.un = (struct sockaddr_un) {
91 : .sun_family = AF_UNIX,
92 : .sun_path = "/run/udev/control",
93 : };
94 :
95 0 : uctrl->addrlen = SOCKADDR_UN_LEN(uctrl->saddr.un);
96 :
97 0 : *ret = TAKE_PTR(uctrl);
98 0 : return 0;
99 : }
100 :
101 0 : int udev_ctrl_enable_receiving(struct udev_ctrl *uctrl) {
102 : int r;
103 :
104 0 : assert(uctrl);
105 :
106 0 : if (uctrl->bound)
107 0 : return 0;
108 :
109 0 : r = bind(uctrl->sock, &uctrl->saddr.sa, uctrl->addrlen);
110 0 : if (r < 0 && errno == EADDRINUSE) {
111 0 : (void) sockaddr_un_unlink(&uctrl->saddr.un);
112 0 : r = bind(uctrl->sock, &uctrl->saddr.sa, uctrl->addrlen);
113 : }
114 :
115 0 : if (r < 0)
116 0 : return log_error_errno(errno, "Failed to bind udev control socket: %m");
117 :
118 0 : if (listen(uctrl->sock, 0) < 0)
119 0 : return log_error_errno(errno, "Failed to listen udev control socket: %m");
120 :
121 0 : uctrl->bound = true;
122 0 : uctrl->cleanup_socket = true;
123 :
124 0 : return 0;
125 : }
126 :
127 0 : static void udev_ctrl_disconnect(struct udev_ctrl *uctrl) {
128 0 : if (!uctrl)
129 0 : return;
130 :
131 0 : uctrl->event_source_connect = sd_event_source_unref(uctrl->event_source_connect);
132 0 : uctrl->sock_connect = safe_close(uctrl->sock_connect);
133 : }
134 :
135 0 : static struct udev_ctrl *udev_ctrl_free(struct udev_ctrl *uctrl) {
136 0 : assert(uctrl);
137 :
138 0 : udev_ctrl_disconnect(uctrl);
139 :
140 0 : sd_event_source_unref(uctrl->event_source);
141 0 : safe_close(uctrl->sock);
142 :
143 0 : sd_event_unref(uctrl->event);
144 0 : return mfree(uctrl);
145 : }
146 :
147 0 : DEFINE_TRIVIAL_REF_UNREF_FUNC(struct udev_ctrl, udev_ctrl, udev_ctrl_free);
148 :
149 0 : int udev_ctrl_cleanup(struct udev_ctrl *uctrl) {
150 0 : if (!uctrl)
151 0 : return 0;
152 0 : if (uctrl->cleanup_socket)
153 0 : sockaddr_un_unlink(&uctrl->saddr.un);
154 0 : return 0;
155 : }
156 :
157 0 : int udev_ctrl_attach_event(struct udev_ctrl *uctrl, sd_event *event) {
158 : int r;
159 :
160 0 : assert_return(uctrl, -EINVAL);
161 0 : assert_return(!uctrl->event, -EBUSY);
162 :
163 0 : if (event)
164 0 : uctrl->event = sd_event_ref(event);
165 : else {
166 0 : r = sd_event_default(&uctrl->event);
167 0 : if (r < 0)
168 0 : return r;
169 : }
170 :
171 0 : return 0;
172 : }
173 :
174 0 : sd_event_source *udev_ctrl_get_event_source(struct udev_ctrl *uctrl) {
175 0 : assert(uctrl);
176 :
177 0 : return uctrl->event_source;
178 : }
179 :
180 0 : static void udev_ctrl_disconnect_and_listen_again(struct udev_ctrl *uctrl) {
181 0 : udev_ctrl_disconnect(uctrl);
182 0 : udev_ctrl_unref(uctrl);
183 0 : (void) sd_event_source_set_enabled(uctrl->event_source, SD_EVENT_ON);
184 0 : }
185 :
186 0 : DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev_ctrl *, udev_ctrl_disconnect_and_listen_again);
187 :
188 0 : static int udev_ctrl_connection_event_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
189 0 : _cleanup_(udev_ctrl_disconnect_and_listen_againp) struct udev_ctrl *uctrl = NULL;
190 : struct udev_ctrl_msg_wire msg_wire;
191 0 : struct iovec iov = IOVEC_MAKE(&msg_wire, sizeof(struct udev_ctrl_msg_wire));
192 : char cred_msg[CMSG_SPACE(sizeof(struct ucred))];
193 0 : struct msghdr smsg = {
194 : .msg_iov = &iov,
195 : .msg_iovlen = 1,
196 : .msg_control = cred_msg,
197 : .msg_controllen = sizeof(cred_msg),
198 : };
199 : struct cmsghdr *cmsg;
200 : struct ucred *cred;
201 : ssize_t size;
202 :
203 0 : assert(userdata);
204 :
205 : /* When UDEV_CTRL_EXIT is received, manager unref udev_ctrl object.
206 : * To avoid the object freed, let's increment the refcount. */
207 0 : uctrl = udev_ctrl_ref(userdata);
208 :
209 0 : size = next_datagram_size_fd(fd);
210 0 : if (size < 0)
211 0 : return log_error_errno(size, "Failed to get size of message: %m");
212 0 : if (size == 0)
213 0 : return 0; /* Client disconnects? */
214 :
215 0 : size = recvmsg(fd, &smsg, 0);
216 0 : if (size < 0) {
217 0 : if (errno != EINTR)
218 0 : return log_error_errno(errno, "Failed to receive ctrl message: %m");
219 :
220 0 : return 0;
221 : }
222 :
223 0 : cmsg_close_all(&smsg);
224 :
225 0 : cmsg = CMSG_FIRSTHDR(&smsg);
226 :
227 0 : if (!cmsg || cmsg->cmsg_type != SCM_CREDENTIALS) {
228 0 : log_error("No sender credentials received, ignoring message");
229 0 : return 0;
230 : }
231 :
232 0 : cred = (struct ucred *) CMSG_DATA(cmsg);
233 :
234 0 : if (cred->uid != 0) {
235 0 : log_error("Invalid sender uid "UID_FMT", ignoring message", cred->uid);
236 0 : return 0;
237 : }
238 :
239 0 : if (msg_wire.magic != UDEV_CTRL_MAGIC) {
240 0 : log_error("Message magic 0x%08x doesn't match, ignoring message", msg_wire.magic);
241 0 : return 0;
242 : }
243 :
244 0 : if (msg_wire.type == _UDEV_CTRL_END_MESSAGES)
245 0 : return 0;
246 :
247 0 : if (uctrl->callback)
248 0 : (void) uctrl->callback(uctrl, msg_wire.type, &msg_wire.value, uctrl->userdata);
249 :
250 : /* Do not disconnect and wait for next message. */
251 0 : uctrl = udev_ctrl_unref(uctrl);
252 0 : return 0;
253 : }
254 :
255 0 : static int udev_ctrl_event_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
256 0 : struct udev_ctrl *uctrl = userdata;
257 0 : _cleanup_close_ int sock = -1;
258 : struct ucred ucred;
259 : int r;
260 :
261 0 : assert(uctrl);
262 :
263 0 : sock = accept4(fd, NULL, NULL, SOCK_CLOEXEC|SOCK_NONBLOCK);
264 0 : if (sock < 0) {
265 0 : if (ERRNO_IS_ACCEPT_AGAIN(errno))
266 0 : return 0;
267 :
268 0 : return log_error_errno(errno, "Failed to accept ctrl connection: %m");
269 : }
270 :
271 : /* check peer credential of connection */
272 0 : r = getpeercred(sock, &ucred);
273 0 : if (r < 0) {
274 0 : log_error_errno(r, "Failed to receive credentials of ctrl connection: %m");
275 0 : return 0;
276 : }
277 :
278 0 : if (ucred.uid > 0) {
279 0 : log_error("Invalid sender uid "UID_FMT", closing connection", ucred.uid);
280 0 : return 0;
281 : }
282 :
283 : /* enable receiving of the sender credentials in the messages */
284 0 : r = setsockopt_int(sock, SOL_SOCKET, SO_PASSCRED, true);
285 0 : if (r < 0)
286 0 : log_warning_errno(r, "Failed to set SO_PASSCRED, ignoring: %m");
287 :
288 0 : r = sd_event_add_io(uctrl->event, &uctrl->event_source_connect, sock, EPOLLIN, udev_ctrl_connection_event_handler, uctrl);
289 0 : if (r < 0) {
290 0 : log_error_errno(r, "Failed to create event source for udev control connection: %m");
291 0 : return 0;
292 : }
293 :
294 0 : (void) sd_event_source_set_description(uctrl->event_source_connect, "udev-ctrl-connection");
295 :
296 : /* Do not accept multiple connection. */
297 0 : (void) sd_event_source_set_enabled(uctrl->event_source, SD_EVENT_OFF);
298 :
299 0 : uctrl->sock_connect = TAKE_FD(sock);
300 0 : return 0;
301 : }
302 :
303 0 : int udev_ctrl_start(struct udev_ctrl *uctrl, udev_ctrl_handler_t callback, void *userdata) {
304 : int r;
305 :
306 0 : assert(uctrl);
307 :
308 0 : if (!uctrl->event) {
309 0 : r = udev_ctrl_attach_event(uctrl, NULL);
310 0 : if (r < 0)
311 0 : return r;
312 : }
313 :
314 0 : r = udev_ctrl_enable_receiving(uctrl);
315 0 : if (r < 0)
316 0 : return r;
317 :
318 0 : uctrl->callback = callback;
319 0 : uctrl->userdata = userdata;
320 :
321 0 : r = sd_event_add_io(uctrl->event, &uctrl->event_source, uctrl->sock, EPOLLIN, udev_ctrl_event_handler, uctrl);
322 0 : if (r < 0)
323 0 : return r;
324 :
325 0 : (void) sd_event_source_set_description(uctrl->event_source, "udev-ctrl");
326 :
327 0 : return 0;
328 : }
329 :
330 0 : int udev_ctrl_send(struct udev_ctrl *uctrl, enum udev_ctrl_msg_type type, int intval, const char *buf) {
331 0 : struct udev_ctrl_msg_wire ctrl_msg_wire = {
332 : .version = "udev-" STRINGIFY(PROJECT_VERSION),
333 : .magic = UDEV_CTRL_MAGIC,
334 : .type = type,
335 : };
336 :
337 0 : if (uctrl->maybe_disconnected)
338 0 : return -ENOANO; /* to distinguish this from other errors. */
339 :
340 0 : if (buf)
341 0 : strscpy(ctrl_msg_wire.value.buf, sizeof(ctrl_msg_wire.value.buf), buf);
342 : else
343 0 : ctrl_msg_wire.value.intval = intval;
344 :
345 0 : if (!uctrl->connected) {
346 0 : if (connect(uctrl->sock, &uctrl->saddr.sa, uctrl->addrlen) < 0)
347 0 : return -errno;
348 0 : uctrl->connected = true;
349 : }
350 :
351 0 : if (send(uctrl->sock, &ctrl_msg_wire, sizeof(ctrl_msg_wire), 0) < 0)
352 0 : return -errno;
353 :
354 0 : if (type == UDEV_CTRL_EXIT)
355 0 : uctrl->maybe_disconnected = true;
356 :
357 0 : return 0;
358 : }
359 :
360 0 : static int udev_ctrl_wait_io_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
361 0 : return sd_event_exit(sd_event_source_get_event(s), 0);
362 : }
363 :
364 0 : int udev_ctrl_wait(struct udev_ctrl *uctrl, usec_t timeout) {
365 0 : _cleanup_(sd_event_source_unrefp) sd_event_source *source_io = NULL, *source_timeout = NULL;
366 : int r;
367 :
368 0 : assert(uctrl);
369 :
370 0 : if (uctrl->sock < 0)
371 0 : return 0;
372 0 : if (!uctrl->connected)
373 0 : return 0;
374 :
375 0 : if (!uctrl->maybe_disconnected) {
376 0 : r = udev_ctrl_send(uctrl, _UDEV_CTRL_END_MESSAGES, 0, NULL);
377 0 : if (r < 0)
378 0 : return r;
379 : }
380 :
381 0 : if (timeout == 0)
382 0 : return 0;
383 :
384 0 : if (!uctrl->event) {
385 0 : r = udev_ctrl_attach_event(uctrl, NULL);
386 0 : if (r < 0)
387 0 : return r;
388 : }
389 :
390 0 : r = sd_event_add_io(uctrl->event, &source_io, uctrl->sock, EPOLLIN, udev_ctrl_wait_io_handler, NULL);
391 0 : if (r < 0)
392 0 : return r;
393 :
394 0 : (void) sd_event_source_set_description(source_io, "udev-ctrl-wait-io");
395 :
396 0 : if (timeout != USEC_INFINITY) {
397 : usec_t usec;
398 :
399 0 : usec = now(clock_boottime_or_monotonic()) + timeout;
400 0 : r = sd_event_add_time(uctrl->event, &source_timeout, clock_boottime_or_monotonic(), usec, 0, NULL, INT_TO_PTR(-ETIMEDOUT));
401 0 : if (r < 0)
402 0 : return r;
403 :
404 0 : (void) sd_event_source_set_description(source_timeout, "udev-ctrl-wait-io");
405 : }
406 :
407 0 : return sd_event_loop(uctrl->event);
408 : }
|
