]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/shared/varlink.c
projects / thirdparty / systemd.git / blob
? search:


7ff81973e1c1d3b55387991f193751ec1d393626
[thirdparty/systemd.git] / src / shared / varlink.c
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <malloc.h>
4 #include <poll.h>
5
6 #include "alloc-util.h"
7 #include "errno-util.h"
8 #include "fd-util.h"
9 #include "glyph-util.h"
10 #include "hashmap.h"
11 #include "io-util.h"
12 #include "list.h"
13 #include "process-util.h"
14 #include "selinux-util.h"
15 #include "serialize.h"
16 #include "set.h"
17 #include "socket-util.h"
18 #include "string-table.h"
19 #include "string-util.h"
20 #include "strv.h"
21 #include "time-util.h"
22 #include "umask-util.h"
23 #include "user-util.h"
24 #include "varlink.h"
25 #include "varlink-internal.h"
26
27 #define VARLINK_DEFAULT_CONNECTIONS_MAX 4096U
28 #define VARLINK_DEFAULT_CONNECTIONS_PER_UID_MAX 1024U
29
30 #define VARLINK_DEFAULT_TIMEOUT_USEC (45U*USEC_PER_SEC)
31 #define VARLINK_BUFFER_MAX (16U*1024U*1024U)
32 #define VARLINK_READ_SIZE (64U*1024U)
33
34 typedef enum VarlinkState {
35 /* Client side states */
36 VARLINK_IDLE_CLIENT,
37 VARLINK_AWAITING_REPLY,
38 VARLINK_AWAITING_REPLY_MORE,
39 VARLINK_CALLING,
40 VARLINK_CALLED,
41 VARLINK_PROCESSING_REPLY,
42
43 /* Server side states */
44 VARLINK_IDLE_SERVER,
45 VARLINK_PROCESSING_METHOD,
46 VARLINK_PROCESSING_METHOD_MORE,
47 VARLINK_PROCESSING_METHOD_ONEWAY,
48 VARLINK_PROCESSED_METHOD,
49 VARLINK_PENDING_METHOD,
50 VARLINK_PENDING_METHOD_MORE,
51
52 /* Common states (only during shutdown) */
53 VARLINK_PENDING_DISCONNECT,
54 VARLINK_PENDING_TIMEOUT,
55 VARLINK_PROCESSING_DISCONNECT,
56 VARLINK_PROCESSING_TIMEOUT,
57 VARLINK_PROCESSING_FAILURE,
58 VARLINK_DISCONNECTED,
59
60 _VARLINK_STATE_MAX,
61 _VARLINK_STATE_INVALID = -EINVAL,
62 } VarlinkState;
63
64 /* Tests whether we are not yet disconnected. Note that this is true during all states where the connection
65 * is still good for something, and false only when it's dead for good. This means: when we are
66 * asynchronously connecting to a peer and the connect() is still pending, then this will return 'true', as
67 * the connection is still good, and we are likely to be able to properly operate on it soon. */
68 #define VARLINK_STATE_IS_ALIVE(state) \
69 IN_SET(state, \
70 VARLINK_IDLE_CLIENT, \
71 VARLINK_AWAITING_REPLY, \
72 VARLINK_AWAITING_REPLY_MORE, \
73 VARLINK_CALLING, \
74 VARLINK_CALLED, \
75 VARLINK_PROCESSING_REPLY, \
76 VARLINK_IDLE_SERVER, \
77 VARLINK_PROCESSING_METHOD, \
78 VARLINK_PROCESSING_METHOD_MORE, \
79 VARLINK_PROCESSING_METHOD_ONEWAY, \
80 VARLINK_PROCESSED_METHOD, \
81 VARLINK_PENDING_METHOD, \
82 VARLINK_PENDING_METHOD_MORE)
83
84 struct Varlink {
85 unsigned n_ref;
86
87 VarlinkServer *server;
88
89 VarlinkState state;
90 bool connecting; /* This boolean indicates whether the socket fd we are operating on is currently
91 * processing an asynchronous connect(). In that state we watch the socket for
92 * EPOLLOUT, but we refrain from calling read() or write() on the socket as that
93 * will trigger ENOTCONN. Note that this boolean is kept separate from the
94 * VarlinkState above on purpose: while the connect() is still not complete we
95 * already want to allow queuing of messages and similar. Thus it's nice to keep
96 * these two state concepts separate: the VarlinkState encodes what our own view of
97 * the connection is, i.e. whether we think it's a server, a client, and has
98 * something queued already, while 'connecting' tells us a detail about the
99 * transport used below, that should have no effect on how we otherwise accept and
100 * process operations from the user.
101 *
102 * Or to say this differently: VARLINK_STATE_IS_ALIVE(state) tells you whether the
103 * connection is good to use, even if it might not be fully connected
104 * yet. connecting=true then informs you that actually we are still connecting, and
105 * the connection is actually not established yet and thus any requests you enqueue
106 * now will still work fine but will be queued only, not sent yet, but that
107 * shouldn't stop you from using the connection, since eventually whatever you queue
108 * *will* be sent.
109 *
110 * Or to say this even differently: 'state' is a high-level ("application layer"
111 * high, if you so will) state, while 'conecting' is a low-level ("transport layer"
112 * low, if you so will) state, and while they are not entirely unrelated and
113 * sometimes propagate effects to each other they are only asynchronously connected
114 * at most. */
115 unsigned n_pending;
116
117 int fd;
118
119 char *input_buffer; /* valid data starts at input_buffer_index, ends at input_buffer_index+input_buffer_size */
120 size_t input_buffer_index;
121 size_t input_buffer_size;
122 size_t input_buffer_unscanned;
123
124 char *output_buffer; /* valid data starts at output_buffer_index, ends at output_buffer_index+output_buffer_size */
125 size_t output_buffer_index;
126 size_t output_buffer_size;
127
128 VarlinkReply reply_callback;
129
130 JsonVariant *current;
131 JsonVariant *reply;
132
133 struct ucred ucred;
134 bool ucred_acquired:1;
135
136 bool write_disconnected:1;
137 bool read_disconnected:1;
138 bool prefer_read_write:1;
139 bool got_pollhup:1;
140
141 usec_t timestamp;
142 usec_t timeout;
143
144 void *userdata;
145 char *description;
146
147 sd_event *event;
148 sd_event_source *io_event_source;
149 sd_event_source *time_event_source;
150 sd_event_source *quit_event_source;
151 sd_event_source *defer_event_source;
152 };
153
154 typedef struct VarlinkServerSocket VarlinkServerSocket;
155
156 struct VarlinkServerSocket {
157 VarlinkServer *server;
158
159 int fd;
160 char *address;
161
162 sd_event_source *event_source;
163
164 LIST_FIELDS(VarlinkServerSocket, sockets);
165 };
166
167 struct VarlinkServer {
168 unsigned n_ref;
169 VarlinkServerFlags flags;
170
171 LIST_HEAD(VarlinkServerSocket, sockets);
172
173 Hashmap *methods;
174 VarlinkConnect connect_callback;
175 VarlinkDisconnect disconnect_callback;
176
177 sd_event *event;
178 int64_t event_priority;
179
180 unsigned n_connections;
181 Hashmap *by_uid;
182
183 void *userdata;
184 char *description;
185
186 unsigned connections_max;
187 unsigned connections_per_uid_max;
188 };
189
190 static const char* const varlink_state_table[_VARLINK_STATE_MAX] = {
191 [VARLINK_IDLE_CLIENT] = "idle-client",
192 [VARLINK_AWAITING_REPLY] = "awaiting-reply",
193 [VARLINK_AWAITING_REPLY_MORE] = "awaiting-reply-more",
194 [VARLINK_CALLING] = "calling",
195 [VARLINK_CALLED] = "called",
196 [VARLINK_PROCESSING_REPLY] = "processing-reply",
197 [VARLINK_IDLE_SERVER] = "idle-server",
198 [VARLINK_PROCESSING_METHOD] = "processing-method",
199 [VARLINK_PROCESSING_METHOD_MORE] = "processing-method-more",
200 [VARLINK_PROCESSING_METHOD_ONEWAY] = "processing-method-oneway",
201 [VARLINK_PROCESSED_METHOD] = "processed-method",
202 [VARLINK_PENDING_METHOD] = "pending-method",
203 [VARLINK_PENDING_METHOD_MORE] = "pending-method-more",
204 [VARLINK_PENDING_DISCONNECT] = "pending-disconnect",
205 [VARLINK_PENDING_TIMEOUT] = "pending-timeout",
206 [VARLINK_PROCESSING_DISCONNECT] = "processing-disconnect",
207 [VARLINK_PROCESSING_TIMEOUT] = "processing-timeout",
208 [VARLINK_PROCESSING_FAILURE] = "processing-failure",
209 [VARLINK_DISCONNECTED] = "disconnected",
210 };
211
212 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(varlink_state, VarlinkState);
213
214 #define varlink_log_errno(v, error, fmt, ...) \
215 log_debug_errno(error, "%s: " fmt, varlink_description(v), ##__VA_ARGS__)
216
217 #define varlink_log(v, fmt, ...) \
218 log_debug("%s: " fmt, varlink_description(v), ##__VA_ARGS__)
219
220 #define varlink_server_log_errno(s, error, fmt, ...) \
221 log_debug_errno(error, "%s: " fmt, varlink_server_description(s), ##__VA_ARGS__)
222
223 #define varlink_server_log(s, fmt, ...) \
224 log_debug("%s: " fmt, varlink_server_description(s), ##__VA_ARGS__)
225
226 static inline const char *varlink_description(Varlink *v) {
227 return (v ? v->description : NULL) ?: "varlink";
228 }
229
230 static inline const char *varlink_server_description(VarlinkServer *s) {
231 return (s ? s->description : NULL) ?: "varlink";
232 }
233
234 static void varlink_set_state(Varlink *v, VarlinkState state) {
235 assert(v);
236 assert(state >= 0 && state < _VARLINK_STATE_MAX);
237
238 if (v->state < 0)
239 varlink_log(v, "Setting state %s",
240 varlink_state_to_string(state));
241 else
242 varlink_log(v, "Changing state %s %s %s",
243 varlink_state_to_string(v->state),
244 special_glyph(SPECIAL_GLYPH_ARROW_RIGHT),
245 varlink_state_to_string(state));
246
247 v->state = state;
248 }
249
250 static int varlink_new(Varlink **ret) {
251 Varlink *v;
252
253 assert(ret);
254
255 v = new(Varlink, 1);
256 if (!v)
257 return -ENOMEM;
258
259 *v = (Varlink) {
260 .n_ref = 1,
261 .fd = -1,
262
263 .state = _VARLINK_STATE_INVALID,
264
265 .ucred = UCRED_INVALID,
266
267 .timestamp = USEC_INFINITY,
268 .timeout = VARLINK_DEFAULT_TIMEOUT_USEC
269 };
270
271 *ret = v;
272 return 0;
273 }
274
275 int varlink_connect_address(Varlink **ret, const char *address) {
276 _cleanup_(varlink_unrefp) Varlink *v = NULL;
277 union sockaddr_union sockaddr;
278 int r;
279
280 assert_return(ret, -EINVAL);
281 assert_return(address, -EINVAL);
282
283 r = varlink_new(&v);
284 if (r < 0)
285 return log_debug_errno(r, "Failed to create varlink object: %m");
286
287 v->fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
288 if (v->fd < 0)
289 return log_debug_errno(errno, "Failed to create AF_UNIX socket: %m");
290
291 v->fd = fd_move_above_stdio(v->fd);
292
293 r = sockaddr_un_set_path(&sockaddr.un, address);
294 if (r < 0) {
295 if (r != -ENAMETOOLONG)
296 return log_debug_errno(r, "Failed to set socket address '%s': %m", address);
297
298 /* This is a file system path, and too long to fit into sockaddr_un. Let's connect via O_PATH
299 * to this socket. */
300
301 r = connect_unix_path(v->fd, AT_FDCWD, address);
302 } else
303 r = RET_NERRNO(connect(v->fd, &sockaddr.sa, r));
304
305 if (r < 0) {
306 if (!IN_SET(r, -EAGAIN, -EINPROGRESS))
307 return log_debug_errno(r, "Failed to connect to %s: %m", address);
308
309 v->connecting = true; /* We are asynchronously connecting, i.e. the connect() is being
310 * processed in the background. As long as that's the case the socket
311 * is in a special state: it's there, we can poll it for EPOLLOUT, but
312 * if we attempt to write() to it before we see EPOLLOUT we'll get
313 * ENOTCONN (and not EAGAIN, like we would for a normal connected
314 * socket that isn't writable at the moment). Since ENOTCONN on write()
315 * hence can mean two different things (i.e. connection not complete
316 * yet vs. already disconnected again), we store as a boolean whether
317 * we are still in connect(). */
318 }
319
320 varlink_set_state(v, VARLINK_IDLE_CLIENT);
321
322 *ret = TAKE_PTR(v);
323 return 0;
324 }
325
326 int varlink_connect_fd(Varlink **ret, int fd) {
327 Varlink *v;
328 int r;
329
330 assert_return(ret, -EINVAL);
331 assert_return(fd >= 0, -EBADF);
332
333 r = fd_nonblock(fd, true);
334 if (r < 0)
335 return log_debug_errno(r, "Failed to make fd %d nonblocking: %m", fd);
336
337 r = varlink_new(&v);
338 if (r < 0)
339 return log_debug_errno(r, "Failed to create varlink object: %m");
340
341 v->fd = fd;
342 varlink_set_state(v, VARLINK_IDLE_CLIENT);
343
344 /* Note that if this function is called we assume the passed socket (if it is one) is already
345 * properly connected, i.e. any asynchronous connect() done on it already completed. Because of that
346 * we'll not set the 'connecting' boolean here, i.e. we don't need to avoid write()ing to the socket
347 * until the connection is fully set up. Behaviour here is hence a bit different from
348 * varlink_connect_address() above, as there we do handle asynchronous connections ourselves and
349 * avoid doing write() on it before we saw EPOLLOUT for the first time. */
350
351 *ret = v;
352 return 0;
353 }
354
355 static void varlink_detach_event_sources(Varlink *v) {
356 assert(v);
357
358 v->io_event_source = sd_event_source_disable_unref(v->io_event_source);
359 v->time_event_source = sd_event_source_disable_unref(v->time_event_source);
360 v->quit_event_source = sd_event_source_disable_unref(v->quit_event_source);
361 v->defer_event_source = sd_event_source_disable_unref(v->defer_event_source);
362 }
363
364 static void varlink_clear(Varlink *v) {
365 assert(v);
366
367 varlink_detach_event_sources(v);
368
369 v->fd = safe_close(v->fd);
370
371 v->input_buffer = mfree(v->input_buffer);
372 v->output_buffer = mfree(v->output_buffer);
373
374 v->current = json_variant_unref(v->current);
375 v->reply = json_variant_unref(v->reply);
376
377 v->event = sd_event_unref(v->event);
378 }
379
380 static Varlink* varlink_destroy(Varlink *v) {
381 if (!v)
382 return NULL;
383
384 /* If this is called the server object must already been unreffed here. Why that? because when we
385 * linked up the varlink connection with the server object we took one ref in each direction */
386 assert(!v->server);
387
388 varlink_clear(v);
389
390 free(v->description);
391 return mfree(v);
392 }
393
394 DEFINE_TRIVIAL_REF_UNREF_FUNC(Varlink, varlink, varlink_destroy);
395
396 static int varlink_test_disconnect(Varlink *v) {
397 assert(v);
398
399 /* Tests whether we the connection has been terminated. We are careful to not stop processing it
400 * prematurely, since we want to handle half-open connections as well as possible and want to flush
401 * out and read data before we close down if we can. */
402
403 /* Already disconnected? */
404 if (!VARLINK_STATE_IS_ALIVE(v->state))
405 return 0;
406
407 /* Wait until connection setup is complete, i.e. until asynchronous connect() completes */
408 if (v->connecting)
409 return 0;
410
411 /* Still something to write and we can write? Stay around */
412 if (v->output_buffer_size > 0 && !v->write_disconnected)
413 return 0;
414
415 /* Both sides gone already? Then there's no need to stick around */
416 if (v->read_disconnected && v->write_disconnected)
417 goto disconnect;
418
419 /* If we are waiting for incoming data but the read side is shut down, disconnect. */
420 if (IN_SET(v->state, VARLINK_AWAITING_REPLY, VARLINK_AWAITING_REPLY_MORE, VARLINK_CALLING, VARLINK_IDLE_SERVER) && v->read_disconnected)
421 goto disconnect;
422
423 /* Similar, if are a client that hasn't written anything yet but the write side is dead, also
424 * disconnect. We also explicitly check for POLLHUP here since we likely won't notice the write side
425 * being down if we never wrote anything. */
426 if (IN_SET(v->state, VARLINK_IDLE_CLIENT) && (v->write_disconnected || v->got_pollhup))
427 goto disconnect;
428
429 /* We are on the server side and still want to send out more replies, but we saw POLLHUP already, and
430 * either got no buffered bytes to write anymore or already saw a write error. In that case we should
431 * shut down the varlink link. */
432 if (IN_SET(v->state, VARLINK_PENDING_METHOD, VARLINK_PENDING_METHOD_MORE) && (v->write_disconnected || v->output_buffer_size == 0) && v->got_pollhup)
433 goto disconnect;
434
435 return 0;
436
437 disconnect:
438 varlink_set_state(v, VARLINK_PENDING_DISCONNECT);
439 return 1;
440 }
441
442 static int varlink_write(Varlink *v) {
443 ssize_t n;
444
445 assert(v);
446
447 if (!VARLINK_STATE_IS_ALIVE(v->state))
448 return 0;
449 if (v->connecting) /* Writing while we are still wait for a non-blocking connect() to complete will
450 * result in ENOTCONN, hence exit early here */
451 return 0;
452 if (v->output_buffer_size == 0)
453 return 0;
454 if (v->write_disconnected)
455 return 0;
456
457 assert(v->fd >= 0);
458
459 /* We generally prefer recv()/send() (mostly because of MSG_NOSIGNAL) but also want to be compatible
460 * with non-socket IO, hence fall back automatically.
461 *
462 * Use a local variable to help gcc figure out that we set 'n' in all cases. */
463 bool prefer_write = v->prefer_read_write;
464 if (!prefer_write) {
465 n = send(v->fd, v->output_buffer + v->output_buffer_index, v->output_buffer_size, MSG_DONTWAIT|MSG_NOSIGNAL);
466 if (n < 0 && errno == ENOTSOCK)
467 prefer_write = v->prefer_read_write = true;
468 }
469 if (prefer_write)
470 n = write(v->fd, v->output_buffer + v->output_buffer_index, v->output_buffer_size);
471 if (n < 0) {
472 if (errno == EAGAIN)
473 return 0;
474
475 if (ERRNO_IS_DISCONNECT(errno)) {
476 /* If we get informed about a disconnect on write, then let's remember that, but not
477 * act on it just yet. Let's wait for read() to report the issue first. */
478 v->write_disconnected = true;
479 return 1;
480 }
481
482 return -errno;
483 }
484
485 v->output_buffer_size -= n;
486
487 if (v->output_buffer_size == 0)
488 v->output_buffer_index = 0;
489 else
490 v->output_buffer_index += n;
491
492 v->timestamp = now(CLOCK_MONOTONIC);
493 return 1;
494 }
495
496 static int varlink_read(Varlink *v) {
497 size_t rs;
498 ssize_t n;
499
500 assert(v);
501
502 if (!IN_SET(v->state, VARLINK_AWAITING_REPLY, VARLINK_AWAITING_REPLY_MORE, VARLINK_CALLING, VARLINK_IDLE_SERVER))
503 return 0;
504 if (v->connecting) /* read() on a socket while we are in connect() will fail with EINVAL, hence exit early here */
505 return 0;
506 if (v->current)
507 return 0;
508 if (v->input_buffer_unscanned > 0)
509 return 0;
510 if (v->read_disconnected)
511 return 0;
512
513 if (v->input_buffer_size >= VARLINK_BUFFER_MAX)
514 return -ENOBUFS;
515
516 assert(v->fd >= 0);
517
518 if (MALLOC_SIZEOF_SAFE(v->input_buffer) <= v->input_buffer_index + v->input_buffer_size) {
519 size_t add;
520
521 add = MIN(VARLINK_BUFFER_MAX - v->input_buffer_size, VARLINK_READ_SIZE);
522
523 if (v->input_buffer_index == 0) {
524
525 if (!GREEDY_REALLOC(v->input_buffer, v->input_buffer_size + add))
526 return -ENOMEM;
527
528 } else {
529 char *b;
530
531 b = new(char, v->input_buffer_size + add);
532 if (!b)
533 return -ENOMEM;
534
535 memcpy(b, v->input_buffer + v->input_buffer_index, v->input_buffer_size);
536
537 free_and_replace(v->input_buffer, b);
538 v->input_buffer_index = 0;
539 }
540 }
541
542 rs = MALLOC_SIZEOF_SAFE(v->input_buffer) - (v->input_buffer_index + v->input_buffer_size);
543
544 bool prefer_read = v->prefer_read_write;
545 if (!prefer_read) {
546 n = recv(v->fd, v->input_buffer + v->input_buffer_index + v->input_buffer_size, rs, MSG_DONTWAIT);
547 if (n < 0 && errno == ENOTSOCK)
548 prefer_read = v->prefer_read_write = true;
549 }
550 if (prefer_read)
551 n = read(v->fd, v->input_buffer + v->input_buffer_index + v->input_buffer_size, rs);
552 if (n < 0) {
553 if (errno == EAGAIN)
554 return 0;
555
556 if (ERRNO_IS_DISCONNECT(errno)) {
557 v->read_disconnected = true;
558 return 1;
559 }
560
561 return -errno;
562 }
563 if (n == 0) { /* EOF */
564 v->read_disconnected = true;
565 return 1;
566 }
567
568 v->input_buffer_size += n;
569 v->input_buffer_unscanned += n;
570
571 return 1;
572 }
573
574 static int varlink_parse_message(Varlink *v) {
575 const char *e, *begin;
576 size_t sz;
577 int r;
578
579 assert(v);
580
581 if (v->current)
582 return 0;
583 if (v->input_buffer_unscanned <= 0)
584 return 0;
585
586 assert(v->input_buffer_unscanned <= v->input_buffer_size);
587 assert(v->input_buffer_index + v->input_buffer_size <= MALLOC_SIZEOF_SAFE(v->input_buffer));
588
589 begin = v->input_buffer + v->input_buffer_index;
590
591 e = memchr(begin + v->input_buffer_size - v->input_buffer_unscanned, 0, v->input_buffer_unscanned);
592 if (!e) {
593 v->input_buffer_unscanned = 0;
594 return 0;
595 }
596
597 sz = e - begin + 1;
598
599 varlink_log(v, "New incoming message: %s", begin); /* FIXME: should we output the whole message here before validation?
600 * This may produce a non-printable journal entry if the message
601 * is invalid. We may also expose privileged information. */
602
603 r = json_parse(begin, 0, &v->current, NULL, NULL);
604 if (r < 0) {
605 /* If we encounter a parse failure flush all data. We cannot possibly recover from this,
606 * hence drop all buffered data now. */
607 v->input_buffer_index = v->input_buffer_size = v->input_buffer_unscanned = 0;
608 return varlink_log_errno(v, r, "Failed to parse JSON: %m");
609 }
610
611 v->input_buffer_size -= sz;
612
613 if (v->input_buffer_size == 0)
614 v->input_buffer_index = 0;
615 else
616 v->input_buffer_index += sz;
617
618 v->input_buffer_unscanned = v->input_buffer_size;
619 return 1;
620 }
621
622 static int varlink_test_timeout(Varlink *v) {
623 assert(v);
624
625 if (!IN_SET(v->state, VARLINK_AWAITING_REPLY, VARLINK_AWAITING_REPLY_MORE, VARLINK_CALLING))
626 return 0;
627 if (v->timeout == USEC_INFINITY)
628 return 0;
629
630 if (now(CLOCK_MONOTONIC) < usec_add(v->timestamp, v->timeout))
631 return 0;
632
633 varlink_set_state(v, VARLINK_PENDING_TIMEOUT);
634
635 return 1;
636 }
637
638 static int varlink_dispatch_local_error(Varlink *v, const char *error) {
639 int r;
640
641 assert(v);
642 assert(error);
643
644 if (!v->reply_callback)
645 return 0;
646
647 r = v->reply_callback(v, NULL, error, VARLINK_REPLY_ERROR|VARLINK_REPLY_LOCAL, v->userdata);
648 if (r < 0)
649 log_debug_errno(r, "Reply callback returned error, ignoring: %m");
650
651 return 1;
652 }
653
654 static int varlink_dispatch_timeout(Varlink *v) {
655 assert(v);
656
657 if (v->state != VARLINK_PENDING_TIMEOUT)
658 return 0;
659
660 varlink_set_state(v, VARLINK_PROCESSING_TIMEOUT);
661 varlink_dispatch_local_error(v, VARLINK_ERROR_TIMEOUT);
662 varlink_close(v);
663
664 return 1;
665 }
666
667 static int varlink_dispatch_disconnect(Varlink *v) {
668 assert(v);
669
670 if (v->state != VARLINK_PENDING_DISCONNECT)
671 return 0;
672
673 varlink_set_state(v, VARLINK_PROCESSING_DISCONNECT);
674 varlink_dispatch_local_error(v, VARLINK_ERROR_DISCONNECTED);
675 varlink_close(v);
676
677 return 1;
678 }
679
680 static int varlink_sanitize_parameters(JsonVariant **v) {
681 assert(v);
682
683 /* Varlink always wants a parameters list, hence make one if the caller doesn't want any */
684 if (!*v)
685 return json_variant_new_object(v, NULL, 0);
686 else if (!json_variant_is_object(*v))
687 return -EINVAL;
688
689 return 0;
690 }
691
692 static int varlink_dispatch_reply(Varlink *v) {
693 _cleanup_(json_variant_unrefp) JsonVariant *parameters = NULL;
694 VarlinkReplyFlags flags = 0;
695 const char *error = NULL;
696 JsonVariant *e;
697 const char *k;
698 int r;
699
700 assert(v);
701
702 if (!IN_SET(v->state, VARLINK_AWAITING_REPLY, VARLINK_AWAITING_REPLY_MORE, VARLINK_CALLING))
703 return 0;
704 if (!v->current)
705 return 0;
706
707 assert(v->n_pending > 0);
708
709 if (!json_variant_is_object(v->current))
710 goto invalid;
711
712 JSON_VARIANT_OBJECT_FOREACH(k, e, v->current) {
713
714 if (streq(k, "error")) {
715 if (error)
716 goto invalid;
717 if (!json_variant_is_string(e))
718 goto invalid;
719
720 error = json_variant_string(e);
721 flags |= VARLINK_REPLY_ERROR;
722
723 } else if (streq(k, "parameters")) {
724 if (parameters)
725 goto invalid;
726 if (!json_variant_is_object(e))
727 goto invalid;
728
729 parameters = json_variant_ref(e);
730
731 } else if (streq(k, "continues")) {
732 if (FLAGS_SET(flags, VARLINK_REPLY_CONTINUES))
733 goto invalid;
734
735 if (!json_variant_is_boolean(e))
736 goto invalid;
737
738 if (json_variant_boolean(e))
739 flags |= VARLINK_REPLY_CONTINUES;
740 } else
741 goto invalid;
742 }
743
744 /* Replies with 'continue' set are only OK if we set 'more' when the method call was initiated */
745 if (v->state != VARLINK_AWAITING_REPLY_MORE && FLAGS_SET(flags, VARLINK_REPLY_CONTINUES))
746 goto invalid;
747
748 /* An error is final */
749 if (error && FLAGS_SET(flags, VARLINK_REPLY_CONTINUES))
750 goto invalid;
751
752 r = varlink_sanitize_parameters(&parameters);
753 if (r < 0)
754 goto invalid;
755
756 if (IN_SET(v->state, VARLINK_AWAITING_REPLY, VARLINK_AWAITING_REPLY_MORE)) {
757 varlink_set_state(v, VARLINK_PROCESSING_REPLY);
758
759 if (v->reply_callback) {
760 r = v->reply_callback(v, parameters, error, flags, v->userdata);
761 if (r < 0)
762 log_debug_errno(r, "Reply callback returned error, ignoring: %m");
763 }
764
765 v->current = json_variant_unref(v->current);
766
767 if (v->state == VARLINK_PROCESSING_REPLY) {
768
769 assert(v->n_pending > 0);
770
771 if (!FLAGS_SET(flags, VARLINK_REPLY_CONTINUES))
772 v->n_pending--;
773
774 varlink_set_state(v,
775 FLAGS_SET(flags, VARLINK_REPLY_CONTINUES) ? VARLINK_AWAITING_REPLY_MORE :
776 v->n_pending == 0 ? VARLINK_IDLE_CLIENT : VARLINK_AWAITING_REPLY);
777 }
778 } else {
779 assert(v->state == VARLINK_CALLING);
780 varlink_set_state(v, VARLINK_CALLED);
781 }
782
783 return 1;
784
785 invalid:
786 varlink_set_state(v, VARLINK_PROCESSING_FAILURE);
787 varlink_dispatch_local_error(v, VARLINK_ERROR_PROTOCOL);
788 varlink_close(v);
789
790 return 1;
791 }
792
793 static int varlink_dispatch_method(Varlink *v) {
794 _cleanup_(json_variant_unrefp) JsonVariant *parameters = NULL;
795 VarlinkMethodFlags flags = 0;
796 const char *method = NULL, *error;
797 JsonVariant *e;
798 VarlinkMethod callback;
799 const char *k;
800 int r;
801
802 assert(v);
803
804 if (v->state != VARLINK_IDLE_SERVER)
805 return 0;
806 if (!v->current)
807 return 0;
808
809 if (!json_variant_is_object(v->current))
810 goto invalid;
811
812 JSON_VARIANT_OBJECT_FOREACH(k, e, v->current) {
813
814 if (streq(k, "method")) {
815 if (method)
816 goto invalid;
817 if (!json_variant_is_string(e))
818 goto invalid;
819
820 method = json_variant_string(e);
821
822 } else if (streq(k, "parameters")) {
823 if (parameters)
824 goto invalid;
825 if (!json_variant_is_object(e))
826 goto invalid;
827
828 parameters = json_variant_ref(e);
829
830 } else if (streq(k, "oneway")) {
831
832 if ((flags & (VARLINK_METHOD_ONEWAY|VARLINK_METHOD_MORE)) != 0)
833 goto invalid;
834
835 if (!json_variant_is_boolean(e))
836 goto invalid;
837
838 if (json_variant_boolean(e))
839 flags |= VARLINK_METHOD_ONEWAY;
840
841 } else if (streq(k, "more")) {
842
843 if ((flags & (VARLINK_METHOD_ONEWAY|VARLINK_METHOD_MORE)) != 0)
844 goto invalid;
845
846 if (!json_variant_is_boolean(e))
847 goto invalid;
848
849 if (json_variant_boolean(e))
850 flags |= VARLINK_METHOD_MORE;
851
852 } else
853 goto invalid;
854 }
855
856 if (!method)
857 goto invalid;
858
859 r = varlink_sanitize_parameters(&parameters);
860 if (r < 0)
861 goto fail;
862
863 varlink_set_state(v, (flags & VARLINK_METHOD_MORE) ? VARLINK_PROCESSING_METHOD_MORE :
864 (flags & VARLINK_METHOD_ONEWAY) ? VARLINK_PROCESSING_METHOD_ONEWAY :
865 VARLINK_PROCESSING_METHOD);
866
867 assert(v->server);
868
869 if (STR_IN_SET(method, "org.varlink.service.GetInfo", "org.varlink.service.GetInterface")) {
870 /* For now, we don't implement a single of varlink's own methods */
871 callback = NULL;
872 error = VARLINK_ERROR_METHOD_NOT_IMPLEMENTED;
873 } else if (startswith(method, "org.varlink.service.")) {
874 callback = NULL;
875 error = VARLINK_ERROR_METHOD_NOT_FOUND;
876 } else {
877 callback = hashmap_get(v->server->methods, method);
878 error = VARLINK_ERROR_METHOD_NOT_FOUND;
879 }
880
881 if (callback) {
882 r = callback(v, parameters, flags, v->userdata);
883 if (r < 0) {
884 log_debug_errno(r, "Callback for %s returned error: %m", method);
885
886 /* We got an error back from the callback. Propagate it to the client if the method call remains unanswered. */
887 if (!FLAGS_SET(flags, VARLINK_METHOD_ONEWAY)) {
888 r = varlink_error_errno(v, r);
889 if (r < 0)
890 return r;
891 }
892 }
893 } else if (!FLAGS_SET(flags, VARLINK_METHOD_ONEWAY)) {
894 assert(error);
895
896 r = varlink_errorb(v, error, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("method", JSON_BUILD_STRING(method))));
897 if (r < 0)
898 return r;
899 }
900
901 switch (v->state) {
902
903 case VARLINK_PROCESSED_METHOD: /* Method call is fully processed */
904 case VARLINK_PROCESSING_METHOD_ONEWAY: /* ditto */
905 v->current = json_variant_unref(v->current);
906 varlink_set_state(v, VARLINK_IDLE_SERVER);
907 break;
908
909 case VARLINK_PROCESSING_METHOD: /* Method call wasn't replied to, will be replied to later */
910 varlink_set_state(v, VARLINK_PENDING_METHOD);
911 break;
912
913 case VARLINK_PROCESSING_METHOD_MORE: /* No reply for a "more" message was sent, more to come */
914 varlink_set_state(v, VARLINK_PENDING_METHOD_MORE);
915 break;
916
917 default:
918 assert_not_reached();
919
920 }
921
922 return r;
923
924 invalid:
925 r = -EINVAL;
926
927 fail:
928 varlink_set_state(v, VARLINK_PROCESSING_FAILURE);
929 varlink_dispatch_local_error(v, VARLINK_ERROR_PROTOCOL);
930 varlink_close(v);
931
932 return r;
933 }
934
935 int varlink_process(Varlink *v) {
936 int r;
937
938 assert_return(v, -EINVAL);
939
940 if (v->state == VARLINK_DISCONNECTED)
941 return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
942
943 varlink_ref(v);
944
945 r = varlink_write(v);
946 if (r < 0)
947 varlink_log_errno(v, r, "Write failed: %m");
948 if (r != 0)
949 goto finish;
950
951 r = varlink_dispatch_reply(v);
952 if (r < 0)
953 varlink_log_errno(v, r, "Reply dispatch failed: %m");
954 if (r != 0)
955 goto finish;
956
957 r = varlink_dispatch_method(v);
958 if (r < 0)
959 varlink_log_errno(v, r, "Method dispatch failed: %m");
960 if (r != 0)
961 goto finish;
962
963 r = varlink_parse_message(v);
964 if (r < 0)
965 varlink_log_errno(v, r, "Message parsing failed: %m");
966 if (r != 0)
967 goto finish;
968
969 r = varlink_read(v);
970 if (r < 0)
971 varlink_log_errno(v, r, "Read failed: %m");
972 if (r != 0)
973 goto finish;
974
975 r = varlink_test_disconnect(v);
976 assert(r >= 0);
977 if (r != 0)
978 goto finish;
979
980 r = varlink_dispatch_disconnect(v);
981 assert(r >= 0);
982 if (r != 0)
983 goto finish;
984
985 r = varlink_test_timeout(v);
986 assert(r >= 0);
987 if (r != 0)
988 goto finish;
989
990 r = varlink_dispatch_timeout(v);
991 assert(r >= 0);
992 if (r != 0)
993 goto finish;
994
995 finish:
996 if (r >= 0 && v->defer_event_source) {
997 int q;
998
999 /* If we did some processing, make sure we are called again soon */
1000 q = sd_event_source_set_enabled(v->defer_event_source, r > 0 ? SD_EVENT_ON : SD_EVENT_OFF);
1001 if (q < 0)
1002 r = varlink_log_errno(v, q, "Failed to enable deferred event source: %m");
1003 }
1004
1005 if (r < 0) {
1006 if (VARLINK_STATE_IS_ALIVE(v->state))
1007 /* Initiate disconnection */
1008 varlink_set_state(v, VARLINK_PENDING_DISCONNECT);
1009 else
1010 /* We failed while disconnecting, in that case close right away */
1011 varlink_close(v);
1012 }
1013
1014 varlink_unref(v);
1015 return r;
1016 }
1017
1018 static void handle_revents(Varlink *v, int revents) {
1019 assert(v);
1020
1021 if (v->connecting) {
1022 /* If we have seen POLLOUT or POLLHUP on a socket we are asynchronously waiting a connect()
1023 * to complete on, we know we are ready. We don't read the connection error here though,
1024 * we'll get the error on the next read() or write(). */
1025 if ((revents & (POLLOUT|POLLHUP)) == 0)
1026 return;
1027
1028 varlink_log(v, "Asynchronous connection completed.");
1029 v->connecting = false;
1030 } else {
1031 /* Note that we don't care much about POLLIN/POLLOUT here, we'll just try reading and writing
1032 * what we can. However, we do care about POLLHUP to detect connection termination even if we
1033 * momentarily don't want to read nor write anything. */
1034
1035 if (!FLAGS_SET(revents, POLLHUP))
1036 return;
1037
1038 varlink_log(v, "Got POLLHUP from socket.");
1039 v->got_pollhup = true;
1040 }
1041 }
1042
1043 int varlink_wait(Varlink *v, usec_t timeout) {
1044 int r, fd, events;
1045 usec_t t;
1046
1047 assert_return(v, -EINVAL);
1048
1049 if (v->state == VARLINK_DISCONNECTED)
1050 return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
1051
1052 r = varlink_get_timeout(v, &t);
1053 if (r < 0)
1054 return r;
1055 if (t != USEC_INFINITY) {
1056 usec_t n;
1057
1058 n = now(CLOCK_MONOTONIC);
1059 if (t < n)
1060 t = 0;
1061 else
1062 t = usec_sub_unsigned(t, n);
1063 }
1064
1065 if (timeout != USEC_INFINITY &&
1066 (t == USEC_INFINITY || timeout < t))
1067 t = timeout;
1068
1069 fd = varlink_get_fd(v);
1070 if (fd < 0)
1071 return fd;
1072
1073 events = varlink_get_events(v);
1074 if (events < 0)
1075 return events;
1076
1077 r = fd_wait_for_event(fd, events, t);
1078 if (r < 0 && ERRNO_IS_TRANSIENT(r)) /* Treat EINTR as not a timeout, but also nothing happened, and
1079 * the caller gets a chance to call back into us */
1080 return 1;
1081 if (r <= 0)
1082 return r;
1083
1084 handle_revents(v, r);
1085 return 1;
1086 }
1087
1088 int varlink_get_fd(Varlink *v) {
1089
1090 assert_return(v, -EINVAL);
1091
1092 if (v->state == VARLINK_DISCONNECTED)
1093 return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
1094 if (v->fd < 0)
1095 return varlink_log_errno(v, SYNTHETIC_ERRNO(EBADF), "No valid fd.");
1096
1097 return v->fd;
1098 }
1099
1100 int varlink_get_events(Varlink *v) {
1101 int ret = 0;
1102
1103 assert_return(v, -EINVAL);
1104
1105 if (v->state == VARLINK_DISCONNECTED)
1106 return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
1107
1108 if (v->connecting) /* When processing an asynchronous connect(), we only wait for EPOLLOUT, which
1109 * tells us that the connection is now complete. Before that we should neither
1110 * write() or read() from the fd. */
1111 return EPOLLOUT;
1112
1113 if (!v->read_disconnected &&
1114 IN_SET(v->state, VARLINK_AWAITING_REPLY, VARLINK_AWAITING_REPLY_MORE, VARLINK_CALLING, VARLINK_IDLE_SERVER) &&
1115 !v->current &&
1116 v->input_buffer_unscanned <= 0)
1117 ret |= EPOLLIN;
1118
1119 if (!v->write_disconnected &&
1120 v->output_buffer_size > 0)
1121 ret |= EPOLLOUT;
1122
1123 return ret;
1124 }
1125
1126 int varlink_get_timeout(Varlink *v, usec_t *ret) {
1127 assert_return(v, -EINVAL);
1128
1129 if (v->state == VARLINK_DISCONNECTED)
1130 return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
1131
1132 if (IN_SET(v->state, VARLINK_AWAITING_REPLY, VARLINK_AWAITING_REPLY_MORE, VARLINK_CALLING) &&
1133 v->timeout != USEC_INFINITY) {
1134 if (ret)
1135 *ret = usec_add(v->timestamp, v->timeout);
1136 return 1;
1137 } else {
1138 if (ret)
1139 *ret = USEC_INFINITY;
1140 return 0;
1141 }
1142 }
1143
1144 int varlink_flush(Varlink *v) {
1145 int ret = 0, r;
1146
1147 assert_return(v, -EINVAL);
1148
1149 if (v->state == VARLINK_DISCONNECTED)
1150 return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
1151
1152 for (;;) {
1153 if (v->output_buffer_size == 0)
1154 break;
1155 if (v->write_disconnected)
1156 return -ECONNRESET;
1157
1158 r = varlink_write(v);
1159 if (r < 0)
1160 return r;
1161 if (r > 0) {
1162 ret = 1;
1163 continue;
1164 }
1165
1166 r = fd_wait_for_event(v->fd, POLLOUT, USEC_INFINITY);
1167 if (r < 0) {
1168 if (ERRNO_IS_TRANSIENT(r))
1169 continue;
1170
1171 return varlink_log_errno(v, r, "Poll failed on fd: %m");
1172 }
1173
1174 assert(r != 0);
1175
1176 handle_revents(v, r);
1177 }
1178
1179 return ret;
1180 }
1181
1182 static void varlink_detach_server(Varlink *v) {
1183 VarlinkServer *saved_server;
1184 assert(v);
1185
1186 if (!v->server)
1187 return;
1188
1189 if (v->server->by_uid &&
1190 v->ucred_acquired &&
1191 uid_is_valid(v->ucred.uid)) {
1192 unsigned c;
1193
1194 c = PTR_TO_UINT(hashmap_get(v->server->by_uid, UID_TO_PTR(v->ucred.uid)));
1195 assert(c > 0);
1196
1197 if (c == 1)
1198 (void) hashmap_remove(v->server->by_uid, UID_TO_PTR(v->ucred.uid));
1199 else
1200 (void) hashmap_replace(v->server->by_uid, UID_TO_PTR(v->ucred.uid), UINT_TO_PTR(c - 1));
1201 }
1202
1203 assert(v->server->n_connections > 0);
1204 v->server->n_connections--;
1205
1206 /* If this is a connection associated to a server, then let's disconnect the server and the
1207 * connection from each other. This drops the dangling reference that connect_callback() set up. But
1208 * before we release the references, let's call the disconnection callback if it is defined. */
1209
1210 saved_server = TAKE_PTR(v->server);
1211
1212 if (saved_server->disconnect_callback)
1213 saved_server->disconnect_callback(saved_server, v, saved_server->userdata);
1214
1215 varlink_server_unref(saved_server);
1216 varlink_unref(v);
1217 }
1218
1219 int varlink_close(Varlink *v) {
1220 assert_return(v, -EINVAL);
1221
1222 if (v->state == VARLINK_DISCONNECTED)
1223 return 0;
1224
1225 varlink_set_state(v, VARLINK_DISCONNECTED);
1226
1227 /* Let's take a reference first, since varlink_detach_server() might drop the final (dangling) ref
1228 * which would destroy us before we can call varlink_clear() */
1229 varlink_ref(v);
1230 varlink_detach_server(v);
1231 varlink_clear(v);
1232 varlink_unref(v);
1233
1234 return 1;
1235 }
1236
1237 Varlink* varlink_close_unref(Varlink *v) {
1238 if (!v)
1239 return NULL;
1240
1241 (void) varlink_close(v);
1242 return varlink_unref(v);
1243 }
1244
1245 Varlink* varlink_flush_close_unref(Varlink *v) {
1246 if (!v)
1247 return NULL;
1248
1249 (void) varlink_flush(v);
1250 return varlink_close_unref(v);
1251 }
1252
1253 static int varlink_enqueue_json(Varlink *v, JsonVariant *m) {
1254 _cleanup_free_ char *text = NULL;
1255 int r;
1256
1257 assert(v);
1258 assert(m);
1259
1260 r = json_variant_format(m, 0, &text);
1261 if (r < 0)
1262 return r;
1263 assert(text[r] == '\0');
1264
1265 if (v->output_buffer_size + r + 1 > VARLINK_BUFFER_MAX)
1266 return -ENOBUFS;
1267
1268 varlink_log(v, "Sending message: %s", text);
1269
1270 if (v->output_buffer_size == 0) {
1271
1272 free_and_replace(v->output_buffer, text);
1273
1274 v->output_buffer_size = r + 1;
1275 v->output_buffer_index = 0;
1276
1277 } else if (v->output_buffer_index == 0) {
1278
1279 if (!GREEDY_REALLOC(v->output_buffer, v->output_buffer_size + r + 1))
1280 return -ENOMEM;
1281
1282 memcpy(v->output_buffer + v->output_buffer_size, text, r + 1);
1283 v->output_buffer_size += r + 1;
1284
1285 } else {
1286 char *n;
1287 const size_t new_size = v->output_buffer_size + r + 1;
1288
1289 n = new(char, new_size);
1290 if (!n)
1291 return -ENOMEM;
1292
1293 memcpy(mempcpy(n, v->output_buffer + v->output_buffer_index, v->output_buffer_size), text, r + 1);
1294
1295 free_and_replace(v->output_buffer, n);
1296 v->output_buffer_size = new_size;
1297 v->output_buffer_index = 0;
1298 }
1299
1300 return 0;
1301 }
1302
1303 int varlink_send(Varlink *v, const char *method, JsonVariant *parameters) {
1304 _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
1305 int r;
1306
1307 assert_return(v, -EINVAL);
1308 assert_return(method, -EINVAL);
1309
1310 if (v->state == VARLINK_DISCONNECTED)
1311 return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
1312
1313 /* We allow enqueuing multiple method calls at once! */
1314 if (!IN_SET(v->state, VARLINK_IDLE_CLIENT, VARLINK_AWAITING_REPLY))
1315 return varlink_log_errno(v, SYNTHETIC_ERRNO(EBUSY), "Connection busy.");
1316
1317 r = varlink_sanitize_parameters(&parameters);
1318 if (r < 0)
1319 return varlink_log_errno(v, r, "Failed to sanitize parameters: %m");
1320
1321 r = json_build(&m, JSON_BUILD_OBJECT(
1322 JSON_BUILD_PAIR("method", JSON_BUILD_STRING(method)),
1323 JSON_BUILD_PAIR("parameters", JSON_BUILD_VARIANT(parameters)),
1324 JSON_BUILD_PAIR("oneway", JSON_BUILD_BOOLEAN(true))));
1325 if (r < 0)
1326 return varlink_log_errno(v, r, "Failed to build json message: %m");
1327
1328 r = varlink_enqueue_json(v, m);
1329 if (r < 0)
1330 return varlink_log_errno(v, r, "Failed to enqueue json message: %m");
1331
1332 /* No state change here, this is one-way only after all */
1333 v->timestamp = now(CLOCK_MONOTONIC);
1334 return 0;
1335 }
1336
1337 int varlink_sendb(Varlink *v, const char *method, ...) {
1338 _cleanup_(json_variant_unrefp) JsonVariant *parameters = NULL;
1339 va_list ap;
1340 int r;
1341
1342 assert_return(v, -EINVAL);
1343
1344 va_start(ap, method);
1345 r = json_buildv(&parameters, ap);
1346 va_end(ap);
1347
1348 if (r < 0)
1349 return varlink_log_errno(v, r, "Failed to build json message: %m");
1350
1351 return varlink_send(v, method, parameters);
1352 }
1353
1354 int varlink_invoke(Varlink *v, const char *method, JsonVariant *parameters) {
1355 _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
1356 int r;
1357
1358 assert_return(v, -EINVAL);
1359 assert_return(method, -EINVAL);
1360
1361 if (v->state == VARLINK_DISCONNECTED)
1362 return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
1363
1364 /* We allow enqueuing multiple method calls at once! */
1365 if (!IN_SET(v->state, VARLINK_IDLE_CLIENT, VARLINK_AWAITING_REPLY))
1366 return varlink_log_errno(v, SYNTHETIC_ERRNO(EBUSY), "Connection busy.");
1367
1368 r = varlink_sanitize_parameters(&parameters);
1369 if (r < 0)
1370 return varlink_log_errno(v, r, "Failed to sanitize parameters: %m");
1371
1372 r = json_build(&m, JSON_BUILD_OBJECT(
1373 JSON_BUILD_PAIR("method", JSON_BUILD_STRING(method)),
1374 JSON_BUILD_PAIR("parameters", JSON_BUILD_VARIANT(parameters))));
1375 if (r < 0)
1376 return varlink_log_errno(v, r, "Failed to build json message: %m");
1377
1378 r = varlink_enqueue_json(v, m);
1379 if (r < 0)
1380 return varlink_log_errno(v, r, "Failed to enqueue json message: %m");
1381
1382 varlink_set_state(v, VARLINK_AWAITING_REPLY);
1383 v->n_pending++;
1384 v->timestamp = now(CLOCK_MONOTONIC);
1385
1386 return 0;
1387 }
1388
1389 int varlink_invokeb(Varlink *v, const char *method, ...) {
1390 _cleanup_(json_variant_unrefp) JsonVariant *parameters = NULL;
1391 va_list ap;
1392 int r;
1393
1394 assert_return(v, -EINVAL);
1395
1396 va_start(ap, method);
1397 r = json_buildv(&parameters, ap);
1398 va_end(ap);
1399
1400 if (r < 0)
1401 return varlink_log_errno(v, r, "Failed to build json message: %m");
1402
1403 return varlink_invoke(v, method, parameters);
1404 }
1405
1406 int varlink_observe(Varlink *v, const char *method, JsonVariant *parameters) {
1407 _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
1408 int r;
1409
1410 assert_return(v, -EINVAL);
1411 assert_return(method, -EINVAL);
1412
1413 if (v->state == VARLINK_DISCONNECTED)
1414 return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
1415
1416 /* Note that we don't allow enqueuing multiple method calls when we are in more/continues mode! We
1417 * thus insist on an idle client here. */
1418 if (v->state != VARLINK_IDLE_CLIENT)
1419 return varlink_log_errno(v, SYNTHETIC_ERRNO(EBUSY), "Connection busy.");
1420
1421 r = varlink_sanitize_parameters(&parameters);
1422 if (r < 0)
1423 return varlink_log_errno(v, r, "Failed to sanitize parameters: %m");
1424
1425 r = json_build(&m, JSON_BUILD_OBJECT(
1426 JSON_BUILD_PAIR("method", JSON_BUILD_STRING(method)),
1427 JSON_BUILD_PAIR("parameters", JSON_BUILD_VARIANT(parameters)),
1428 JSON_BUILD_PAIR("more", JSON_BUILD_BOOLEAN(true))));
1429 if (r < 0)
1430 return varlink_log_errno(v, r, "Failed to build json message: %m");
1431
1432 r = varlink_enqueue_json(v, m);
1433 if (r < 0)
1434 return varlink_log_errno(v, r, "Failed to enqueue json message: %m");
1435
1436 varlink_set_state(v, VARLINK_AWAITING_REPLY_MORE);
1437 v->n_pending++;
1438 v->timestamp = now(CLOCK_MONOTONIC);
1439
1440 return 0;
1441 }
1442
1443 int varlink_observeb(Varlink *v, const char *method, ...) {
1444 _cleanup_(json_variant_unrefp) JsonVariant *parameters = NULL;
1445 va_list ap;
1446 int r;
1447
1448 assert_return(v, -EINVAL);
1449
1450 va_start(ap, method);
1451 r = json_buildv(&parameters, ap);
1452 va_end(ap);
1453
1454 if (r < 0)
1455 return varlink_log_errno(v, r, "Failed to build json message: %m");
1456
1457 return varlink_observe(v, method, parameters);
1458 }
1459
1460 int varlink_call(
1461 Varlink *v,
1462 const char *method,
1463 JsonVariant *parameters,
1464 JsonVariant **ret_parameters,
1465 const char **ret_error_id,
1466 VarlinkReplyFlags *ret_flags) {
1467
1468 _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
1469 int r;
1470
1471 assert_return(v, -EINVAL);
1472 assert_return(method, -EINVAL);
1473
1474 if (v->state == VARLINK_DISCONNECTED)
1475 return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
1476 if (!IN_SET(v->state, VARLINK_IDLE_CLIENT))
1477 return varlink_log_errno(v, SYNTHETIC_ERRNO(EBUSY), "Connection busy.");
1478
1479 assert(v->n_pending == 0); /* n_pending can't be > 0 if we are in VARLINK_IDLE_CLIENT state */
1480
1481 r = varlink_sanitize_parameters(&parameters);
1482 if (r < 0)
1483 return varlink_log_errno(v, r, "Failed to sanitize parameters: %m");
1484
1485 r = json_build(&m, JSON_BUILD_OBJECT(
1486 JSON_BUILD_PAIR("method", JSON_BUILD_STRING(method)),
1487 JSON_BUILD_PAIR("parameters", JSON_BUILD_VARIANT(parameters))));
1488 if (r < 0)
1489 return varlink_log_errno(v, r, "Failed to build json message: %m");
1490
1491 r = varlink_enqueue_json(v, m);
1492 if (r < 0)
1493 return varlink_log_errno(v, r, "Failed to enqueue json message: %m");
1494
1495 varlink_set_state(v, VARLINK_CALLING);
1496 v->n_pending++;
1497 v->timestamp = now(CLOCK_MONOTONIC);
1498
1499 while (v->state == VARLINK_CALLING) {
1500
1501 r = varlink_process(v);
1502 if (r < 0)
1503 return r;
1504 if (r > 0)
1505 continue;
1506
1507 r = varlink_wait(v, USEC_INFINITY);
1508 if (r < 0)
1509 return r;
1510 }
1511
1512 switch (v->state) {
1513
1514 case VARLINK_CALLED:
1515 assert(v->current);
1516
1517 json_variant_unref(v->reply);
1518 v->reply = TAKE_PTR(v->current);
1519
1520 varlink_set_state(v, VARLINK_IDLE_CLIENT);
1521 assert(v->n_pending == 1);
1522 v->n_pending--;
1523
1524 if (ret_parameters)
1525 *ret_parameters = json_variant_by_key(v->reply, "parameters");
1526 if (ret_error_id)
1527 *ret_error_id = json_variant_string(json_variant_by_key(v->reply, "error"));
1528 if (ret_flags)
1529 *ret_flags = 0;
1530
1531 return 1;
1532
1533 case VARLINK_PENDING_DISCONNECT:
1534 case VARLINK_DISCONNECTED:
1535 return varlink_log_errno(v, SYNTHETIC_ERRNO(ECONNRESET), "Connection was closed.");
1536
1537 case VARLINK_PENDING_TIMEOUT:
1538 return varlink_log_errno(v, SYNTHETIC_ERRNO(ETIME), "Connection timed out.");
1539
1540 default:
1541 assert_not_reached();
1542 }
1543 }
1544
1545 int varlink_callb(
1546 Varlink *v,
1547 const char *method,
1548 JsonVariant **ret_parameters,
1549 const char **ret_error_id,
1550 VarlinkReplyFlags *ret_flags, ...) {
1551
1552 _cleanup_(json_variant_unrefp) JsonVariant *parameters = NULL;
1553 va_list ap;
1554 int r;
1555
1556 assert_return(v, -EINVAL);
1557
1558 va_start(ap, ret_flags);
1559 r = json_buildv(&parameters, ap);
1560 va_end(ap);
1561
1562 if (r < 0)
1563 return varlink_log_errno(v, r, "Failed to build json message: %m");
1564
1565 return varlink_call(v, method, parameters, ret_parameters, ret_error_id, ret_flags);
1566 }
1567
1568 int varlink_reply(Varlink *v, JsonVariant *parameters) {
1569 _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
1570 int r;
1571
1572 assert_return(v, -EINVAL);
1573
1574 if (v->state == VARLINK_DISCONNECTED)
1575 return -ENOTCONN;
1576 if (!IN_SET(v->state,
1577 VARLINK_PROCESSING_METHOD, VARLINK_PROCESSING_METHOD_MORE,
1578 VARLINK_PENDING_METHOD, VARLINK_PENDING_METHOD_MORE))
1579 return -EBUSY;
1580
1581 r = varlink_sanitize_parameters(&parameters);
1582 if (r < 0)
1583 return varlink_log_errno(v, r, "Failed to sanitize parameters: %m");
1584
1585 r = json_build(&m, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("parameters", JSON_BUILD_VARIANT(parameters))));
1586 if (r < 0)
1587 return varlink_log_errno(v, r, "Failed to build json message: %m");
1588
1589 r = varlink_enqueue_json(v, m);
1590 if (r < 0)
1591 return varlink_log_errno(v, r, "Failed to enqueue json message: %m");
1592
1593 if (IN_SET(v->state, VARLINK_PENDING_METHOD, VARLINK_PENDING_METHOD_MORE)) {
1594 /* We just replied to a method call that was let hanging for a while (i.e. we were outside of
1595 * the varlink_dispatch_method() stack frame), which means with this reply we are ready to
1596 * process further messages. */
1597 v->current = json_variant_unref(v->current);
1598 varlink_set_state(v, VARLINK_IDLE_SERVER);
1599 } else
1600 /* We replied to a method call from within the varlink_dispatch_method() stack frame), which
1601 * means we should it handle the rest of the state engine. */
1602 varlink_set_state(v, VARLINK_PROCESSED_METHOD);
1603
1604 return 1;
1605 }
1606
1607 int varlink_replyb(Varlink *v, ...) {
1608 _cleanup_(json_variant_unrefp) JsonVariant *parameters = NULL;
1609 va_list ap;
1610 int r;
1611
1612 assert_return(v, -EINVAL);
1613
1614 va_start(ap, v);
1615 r = json_buildv(&parameters, ap);
1616 va_end(ap);
1617
1618 if (r < 0)
1619 return r;
1620
1621 return varlink_reply(v, parameters);
1622 }
1623
1624 int varlink_error(Varlink *v, const char *error_id, JsonVariant *parameters) {
1625 _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
1626 int r;
1627
1628 assert_return(v, -EINVAL);
1629 assert_return(error_id, -EINVAL);
1630
1631 if (v->state == VARLINK_DISCONNECTED)
1632 return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
1633 if (!IN_SET(v->state,
1634 VARLINK_PROCESSING_METHOD, VARLINK_PROCESSING_METHOD_MORE,
1635 VARLINK_PENDING_METHOD, VARLINK_PENDING_METHOD_MORE))
1636 return varlink_log_errno(v, SYNTHETIC_ERRNO(EBUSY), "Connection busy.");
1637
1638 r = varlink_sanitize_parameters(&parameters);
1639 if (r < 0)
1640 return varlink_log_errno(v, r, "Failed to sanitize parameters: %m");
1641
1642 r = json_build(&m, JSON_BUILD_OBJECT(
1643 JSON_BUILD_PAIR("error", JSON_BUILD_STRING(error_id)),
1644 JSON_BUILD_PAIR("parameters", JSON_BUILD_VARIANT(parameters))));
1645 if (r < 0)
1646 return varlink_log_errno(v, r, "Failed to build json message: %m");
1647
1648 r = varlink_enqueue_json(v, m);
1649 if (r < 0)
1650 return varlink_log_errno(v, r, "Failed to enqueue json message: %m");
1651
1652 if (IN_SET(v->state, VARLINK_PENDING_METHOD, VARLINK_PENDING_METHOD_MORE)) {
1653 v->current = json_variant_unref(v->current);
1654 varlink_set_state(v, VARLINK_IDLE_SERVER);
1655 } else
1656 varlink_set_state(v, VARLINK_PROCESSED_METHOD);
1657
1658 return 1;
1659 }
1660
1661 int varlink_errorb(Varlink *v, const char *error_id, ...) {
1662 _cleanup_(json_variant_unrefp) JsonVariant *parameters = NULL;
1663 va_list ap;
1664 int r;
1665
1666 assert_return(v, -EINVAL);
1667 assert_return(error_id, -EINVAL);
1668
1669 va_start(ap, error_id);
1670 r = json_buildv(&parameters, ap);
1671 va_end(ap);
1672
1673 if (r < 0)
1674 return varlink_log_errno(v, r, "Failed to build json message: %m");
1675
1676 return varlink_error(v, error_id, parameters);
1677 }
1678
1679 int varlink_error_invalid_parameter(Varlink *v, JsonVariant *parameters) {
1680 int r;
1681
1682 assert_return(v, -EINVAL);
1683 assert_return(parameters, -EINVAL);
1684
1685 /* We expect to be called in one of two ways: the 'parameters' argument is a string variant in which
1686 * case it is the parameter key name that is invalid. Or the 'parameters' argument is an object
1687 * variant in which case we'll pull out the first key. The latter mode is useful in functions that
1688 * don't expect any arguments. */
1689
1690 /* varlink_error(...) expects a json object as the third parameter. Passing a string variant causes
1691 * parameter sanitization to fail, and it returns -EINVAL. */
1692
1693 if (json_variant_is_string(parameters)) {
1694 _cleanup_(json_variant_unrefp) JsonVariant *parameters_obj = NULL;
1695
1696 r = json_build(&parameters_obj,
1697 JSON_BUILD_OBJECT(
1698 JSON_BUILD_PAIR("parameter", JSON_BUILD_VARIANT(parameters))));
1699 if (r < 0)
1700 return r;
1701
1702 return varlink_error(v, VARLINK_ERROR_INVALID_PARAMETER, parameters_obj);
1703 }
1704
1705 if (json_variant_is_object(parameters) &&
1706 json_variant_elements(parameters) > 0) {
1707 _cleanup_(json_variant_unrefp) JsonVariant *parameters_obj = NULL;
1708
1709 r = json_build(&parameters_obj,
1710 JSON_BUILD_OBJECT(
1711 JSON_BUILD_PAIR("parameter", JSON_BUILD_VARIANT(json_variant_by_index(parameters, 0)))));
1712 if (r < 0)
1713 return r;
1714
1715 return varlink_error(v, VARLINK_ERROR_INVALID_PARAMETER, parameters_obj);
1716 }
1717
1718 return -EINVAL;
1719 }
1720
1721 int varlink_error_errno(Varlink *v, int error) {
1722 return varlink_errorb(
1723 v,
1724 VARLINK_ERROR_SYSTEM,
1725 JSON_BUILD_OBJECT(JSON_BUILD_PAIR("errno", JSON_BUILD_INTEGER(abs(error)))));
1726 }
1727
1728 int varlink_notify(Varlink *v, JsonVariant *parameters) {
1729 _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
1730 int r;
1731
1732 assert_return(v, -EINVAL);
1733
1734 if (v->state == VARLINK_DISCONNECTED)
1735 return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
1736 if (!IN_SET(v->state, VARLINK_PROCESSING_METHOD_MORE, VARLINK_PENDING_METHOD_MORE))
1737 return varlink_log_errno(v, SYNTHETIC_ERRNO(EBUSY), "Connection busy.");
1738
1739 r = varlink_sanitize_parameters(&parameters);
1740 if (r < 0)
1741 return varlink_log_errno(v, r, "Failed to sanitize parameters: %m");
1742
1743 r = json_build(&m, JSON_BUILD_OBJECT(
1744 JSON_BUILD_PAIR("parameters", JSON_BUILD_VARIANT(parameters)),
1745 JSON_BUILD_PAIR("continues", JSON_BUILD_BOOLEAN(true))));
1746 if (r < 0)
1747 return varlink_log_errno(v, r, "Failed to build json message: %m");
1748
1749 r = varlink_enqueue_json(v, m);
1750 if (r < 0)
1751 return varlink_log_errno(v, r, "Failed to enqueue json message: %m");
1752
1753 /* No state change, as more is coming */
1754 return 1;
1755 }
1756
1757 int varlink_notifyb(Varlink *v, ...) {
1758 _cleanup_(json_variant_unrefp) JsonVariant *parameters = NULL;
1759 va_list ap;
1760 int r;
1761
1762 assert_return(v, -EINVAL);
1763
1764 va_start(ap, v);
1765 r = json_buildv(&parameters, ap);
1766 va_end(ap);
1767
1768 if (r < 0)
1769 return varlink_log_errno(v, r, "Failed to build json message: %m");
1770
1771 return varlink_notify(v, parameters);
1772 }
1773
1774 int varlink_bind_reply(Varlink *v, VarlinkReply callback) {
1775 assert_return(v, -EINVAL);
1776
1777 if (callback && v->reply_callback && callback != v->reply_callback)
1778 return varlink_log_errno(v, SYNTHETIC_ERRNO(EBUSY), "A different callback was already set.");
1779
1780 v->reply_callback = callback;
1781
1782 return 0;
1783 }
1784
1785 void* varlink_set_userdata(Varlink *v, void *userdata) {
1786 void *old;
1787
1788 assert_return(v, NULL);
1789
1790 old = v->userdata;
1791 v->userdata = userdata;
1792
1793 return old;
1794 }
1795
1796 void* varlink_get_userdata(Varlink *v) {
1797 assert_return(v, NULL);
1798
1799 return v->userdata;
1800 }
1801
1802 static int varlink_acquire_ucred(Varlink *v) {
1803 int r;
1804
1805 assert(v);
1806
1807 if (v->ucred_acquired)
1808 return 0;
1809
1810 r = getpeercred(v->fd, &v->ucred);
1811 if (r < 0)
1812 return r;
1813
1814 v->ucred_acquired = true;
1815 return 0;
1816 }
1817
1818 int varlink_get_peer_uid(Varlink *v, uid_t *ret) {
1819 int r;
1820
1821 assert_return(v, -EINVAL);
1822 assert_return(ret, -EINVAL);
1823
1824 r = varlink_acquire_ucred(v);
1825 if (r < 0)
1826 return varlink_log_errno(v, r, "Failed to acquire credentials: %m");
1827
1828 if (!uid_is_valid(v->ucred.uid))
1829 return varlink_log_errno(v, SYNTHETIC_ERRNO(ENODATA), "Peer uid is invalid.");
1830
1831 *ret = v->ucred.uid;
1832 return 0;
1833 }
1834
1835 int varlink_get_peer_pid(Varlink *v, pid_t *ret) {
1836 int r;
1837
1838 assert_return(v, -EINVAL);
1839 assert_return(ret, -EINVAL);
1840
1841 r = varlink_acquire_ucred(v);
1842 if (r < 0)
1843 return varlink_log_errno(v, r, "Failed to acquire credentials: %m");
1844
1845 if (!pid_is_valid(v->ucred.pid))
1846 return varlink_log_errno(v, SYNTHETIC_ERRNO(ENODATA), "Peer uid is invalid.");
1847
1848 *ret = v->ucred.pid;
1849 return 0;
1850 }
1851
1852 int varlink_set_relative_timeout(Varlink *v, usec_t timeout) {
1853 assert_return(v, -EINVAL);
1854 assert_return(timeout > 0, -EINVAL);
1855
1856 v->timeout = timeout;
1857 return 0;
1858 }
1859
1860 VarlinkServer *varlink_get_server(Varlink *v) {
1861 assert_return(v, NULL);
1862
1863 return v->server;
1864 }
1865
1866 int varlink_set_description(Varlink *v, const char *description) {
1867 assert_return(v, -EINVAL);
1868
1869 return free_and_strdup(&v->description, description);
1870 }
1871
1872 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1873 Varlink *v = ASSERT_PTR(userdata);
1874
1875 assert(s);
1876
1877 handle_revents(v, revents);
1878 (void) varlink_process(v);
1879
1880 return 1;
1881 }
1882
1883 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
1884 Varlink *v = ASSERT_PTR(userdata);
1885
1886 assert(s);
1887
1888 (void) varlink_process(v);
1889 return 1;
1890 }
1891
1892 static int defer_callback(sd_event_source *s, void *userdata) {
1893 Varlink *v = ASSERT_PTR(userdata);
1894
1895 assert(s);
1896
1897 (void) varlink_process(v);
1898 return 1;
1899 }
1900
1901 static int prepare_callback(sd_event_source *s, void *userdata) {
1902 Varlink *v = ASSERT_PTR(userdata);
1903 int r, e;
1904 usec_t until;
1905 bool have_timeout;
1906
1907 assert(s);
1908
1909 e = varlink_get_events(v);
1910 if (e < 0)
1911 return e;
1912
1913 r = sd_event_source_set_io_events(v->io_event_source, e);
1914 if (r < 0)
1915 return varlink_log_errno(v, r, "Failed to set source events: %m");
1916
1917 r = varlink_get_timeout(v, &until);
1918 if (r < 0)
1919 return r;
1920 have_timeout = r > 0;
1921
1922 if (have_timeout) {
1923 r = sd_event_source_set_time(v->time_event_source, until);
1924 if (r < 0)
1925 return varlink_log_errno(v, r, "Failed to set source time: %m");
1926 }
1927
1928 r = sd_event_source_set_enabled(v->time_event_source, have_timeout ? SD_EVENT_ON : SD_EVENT_OFF);
1929 if (r < 0)
1930 return varlink_log_errno(v, r, "Failed to enable event source: %m");
1931
1932 return 1;
1933 }
1934
1935 static int quit_callback(sd_event_source *event, void *userdata) {
1936 Varlink *v = ASSERT_PTR(userdata);
1937
1938 assert(event);
1939
1940 varlink_flush(v);
1941 varlink_close(v);
1942
1943 return 1;
1944 }
1945
1946 int varlink_attach_event(Varlink *v, sd_event *e, int64_t priority) {
1947 int r;
1948
1949 assert_return(v, -EINVAL);
1950 assert_return(!v->event, -EBUSY);
1951
1952 if (e)
1953 v->event = sd_event_ref(e);
1954 else {
1955 r = sd_event_default(&v->event);
1956 if (r < 0)
1957 return varlink_log_errno(v, r, "Failed to create event source: %m");
1958 }
1959
1960 r = sd_event_add_time(v->event, &v->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, v);
1961 if (r < 0)
1962 goto fail;
1963
1964 r = sd_event_source_set_priority(v->time_event_source, priority);
1965 if (r < 0)
1966 goto fail;
1967
1968 (void) sd_event_source_set_description(v->time_event_source, "varlink-time");
1969
1970 r = sd_event_add_exit(v->event, &v->quit_event_source, quit_callback, v);
1971 if (r < 0)
1972 goto fail;
1973
1974 r = sd_event_source_set_priority(v->quit_event_source, priority);
1975 if (r < 0)
1976 goto fail;
1977
1978 (void) sd_event_source_set_description(v->quit_event_source, "varlink-quit");
1979
1980 r = sd_event_add_io(v->event, &v->io_event_source, v->fd, 0, io_callback, v);
1981 if (r < 0)
1982 goto fail;
1983
1984 r = sd_event_source_set_prepare(v->io_event_source, prepare_callback);
1985 if (r < 0)
1986 goto fail;
1987
1988 r = sd_event_source_set_priority(v->io_event_source, priority);
1989 if (r < 0)
1990 goto fail;
1991
1992 (void) sd_event_source_set_description(v->io_event_source, "varlink-io");
1993
1994 r = sd_event_add_defer(v->event, &v->defer_event_source, defer_callback, v);
1995 if (r < 0)
1996 goto fail;
1997
1998 r = sd_event_source_set_priority(v->defer_event_source, priority);
1999 if (r < 0)
2000 goto fail;
2001
2002 (void) sd_event_source_set_description(v->defer_event_source, "varlink-defer");
2003
2004 return 0;
2005
2006 fail:
2007 varlink_log_errno(v, r, "Failed to setup event source: %m");
2008 varlink_detach_event(v);
2009 return r;
2010 }
2011
2012 void varlink_detach_event(Varlink *v) {
2013 if (!v)
2014 return;
2015
2016 varlink_detach_event_sources(v);
2017
2018 v->event = sd_event_unref(v->event);
2019 }
2020
2021 sd_event *varlink_get_event(Varlink *v) {
2022 assert_return(v, NULL);
2023
2024 return v->event;
2025 }
2026
2027 int varlink_server_new(VarlinkServer **ret, VarlinkServerFlags flags) {
2028 VarlinkServer *s;
2029
2030 assert_return(ret, -EINVAL);
2031 assert_return((flags & ~_VARLINK_SERVER_FLAGS_ALL) == 0, -EINVAL);
2032
2033 s = new(VarlinkServer, 1);
2034 if (!s)
2035 return log_oom_debug();
2036
2037 *s = (VarlinkServer) {
2038 .n_ref = 1,
2039 .flags = flags,
2040 .connections_max = varlink_server_connections_max(NULL),
2041 .connections_per_uid_max = varlink_server_connections_per_uid_max(NULL),
2042 };
2043
2044 *ret = s;
2045 return 0;
2046 }
2047
2048 static VarlinkServer* varlink_server_destroy(VarlinkServer *s) {
2049 char *m;
2050
2051 if (!s)
2052 return NULL;
2053
2054 varlink_server_shutdown(s);
2055
2056 while ((m = hashmap_steal_first_key(s->methods)))
2057 free(m);
2058
2059 hashmap_free(s->methods);
2060 hashmap_free(s->by_uid);
2061
2062 sd_event_unref(s->event);
2063
2064 free(s->description);
2065
2066 return mfree(s);
2067 }
2068
2069 DEFINE_TRIVIAL_REF_UNREF_FUNC(VarlinkServer, varlink_server, varlink_server_destroy);
2070
2071 static int validate_connection(VarlinkServer *server, const struct ucred *ucred) {
2072 int allowed = -1;
2073
2074 assert(server);
2075 assert(ucred);
2076
2077 if (FLAGS_SET(server->flags, VARLINK_SERVER_ROOT_ONLY))
2078 allowed = ucred->uid == 0;
2079
2080 if (FLAGS_SET(server->flags, VARLINK_SERVER_MYSELF_ONLY))
2081 allowed = allowed > 0 || ucred->uid == getuid();
2082
2083 if (allowed == 0) { /* Allow access when it is explicitly allowed or when neither
2084 * VARLINK_SERVER_ROOT_ONLY nor VARLINK_SERVER_MYSELF_ONLY are specified. */
2085 varlink_server_log(server, "Unprivileged client attempted connection, refusing.");
2086 return 0;
2087 }
2088
2089 if (server->n_connections >= server->connections_max) {
2090 varlink_server_log(server, "Connection limit of %u reached, refusing.", server->connections_max);
2091 return 0;
2092 }
2093
2094 if (FLAGS_SET(server->flags, VARLINK_SERVER_ACCOUNT_UID)) {
2095 unsigned c;
2096
2097 if (!uid_is_valid(ucred->uid)) {
2098 varlink_server_log(server, "Client with invalid UID attempted connection, refusing.");
2099 return 0;
2100 }
2101
2102 c = PTR_TO_UINT(hashmap_get(server->by_uid, UID_TO_PTR(ucred->uid)));
2103 if (c >= server->connections_per_uid_max) {
2104 varlink_server_log(server, "Per-UID connection limit of %u reached, refusing.",
2105 server->connections_per_uid_max);
2106 return 0;
2107 }
2108 }
2109
2110 return 1;
2111 }
2112
2113 static int count_connection(VarlinkServer *server, const struct ucred *ucred) {
2114 unsigned c;
2115 int r;
2116
2117 assert(server);
2118 assert(ucred);
2119
2120 server->n_connections++;
2121
2122 if (FLAGS_SET(server->flags, VARLINK_SERVER_ACCOUNT_UID)) {
2123 r = hashmap_ensure_allocated(&server->by_uid, NULL);
2124 if (r < 0)
2125 return log_debug_errno(r, "Failed to allocate UID hash table: %m");
2126
2127 c = PTR_TO_UINT(hashmap_get(server->by_uid, UID_TO_PTR(ucred->uid)));
2128
2129 varlink_server_log(server, "Connections of user " UID_FMT ": %u (of %u max)",
2130 ucred->uid, c, server->connections_per_uid_max);
2131
2132 r = hashmap_replace(server->by_uid, UID_TO_PTR(ucred->uid), UINT_TO_PTR(c + 1));
2133 if (r < 0)
2134 return log_debug_errno(r, "Failed to increment counter in UID hash table: %m");
2135 }
2136
2137 return 0;
2138 }
2139
2140 int varlink_server_add_connection(VarlinkServer *server, int fd, Varlink **ret) {
2141 _cleanup_(varlink_unrefp) Varlink *v = NULL;
2142 struct ucred ucred = UCRED_INVALID;
2143 bool ucred_acquired;
2144 int r;
2145
2146 assert_return(server, -EINVAL);
2147 assert_return(fd >= 0, -EBADF);
2148
2149 if ((server->flags & (VARLINK_SERVER_ROOT_ONLY|VARLINK_SERVER_ACCOUNT_UID)) != 0) {
2150 r = getpeercred(fd, &ucred);
2151 if (r < 0)
2152 return varlink_server_log_errno(server, r, "Failed to acquire peer credentials of incoming socket, refusing: %m");
2153
2154 ucred_acquired = true;
2155
2156 r = validate_connection(server, &ucred);
2157 if (r < 0)
2158 return r;
2159 if (r == 0)
2160 return -EPERM;
2161 } else
2162 ucred_acquired = false;
2163
2164 r = varlink_new(&v);
2165 if (r < 0)
2166 return varlink_server_log_errno(server, r, "Failed to allocate connection object: %m");
2167
2168 r = count_connection(server, &ucred);
2169 if (r < 0)
2170 return r;
2171
2172 v->fd = fd;
2173 if (server->flags & VARLINK_SERVER_INHERIT_USERDATA)
2174 v->userdata = server->userdata;
2175
2176 if (ucred_acquired) {
2177 v->ucred = ucred;
2178 v->ucred_acquired = true;
2179 }
2180
2181 _cleanup_free_ char *desc = NULL;
2182 if (asprintf(&desc, "%s-%i", server->description ?: "varlink", v->fd) >= 0)
2183 v->description = TAKE_PTR(desc);
2184
2185 /* Link up the server and the connection, and take reference in both directions. Note that the
2186 * reference on the connection is left dangling. It will be dropped when the connection is closed,
2187 * which happens in varlink_close(), including in the event loop quit callback. */
2188 v->server = varlink_server_ref(server);
2189 varlink_ref(v);
2190
2191 varlink_set_state(v, VARLINK_IDLE_SERVER);
2192
2193 if (server->event) {
2194 r = varlink_attach_event(v, server->event, server->event_priority);
2195 if (r < 0) {
2196 varlink_log_errno(v, r, "Failed to attach new connection: %m");
2197 v->fd = -1; /* take the fd out of the connection again */
2198 varlink_close(v);
2199 return r;
2200 }
2201 }
2202
2203 if (ret)
2204 *ret = v;
2205
2206 return 0;
2207 }
2208
2209 static VarlinkServerSocket *varlink_server_socket_free(VarlinkServerSocket *ss) {
2210 if (!ss)
2211 return NULL;
2212
2213 free(ss->address);
2214 return mfree(ss);
2215 }
2216
2217 DEFINE_TRIVIAL_CLEANUP_FUNC(VarlinkServerSocket *, varlink_server_socket_free);
2218
2219 static int connect_callback(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2220 VarlinkServerSocket *ss = ASSERT_PTR(userdata);
2221 _cleanup_close_ int cfd = -1;
2222 Varlink *v = NULL;
2223 int r;
2224
2225 assert(source);
2226
2227 varlink_server_log(ss->server, "New incoming connection.");
2228
2229 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);
2230 if (cfd < 0) {
2231 if (ERRNO_IS_ACCEPT_AGAIN(errno))
2232 return 0;
2233
2234 return varlink_server_log_errno(ss->server, errno, "Failed to accept incoming socket: %m");
2235 }
2236
2237 r = varlink_server_add_connection(ss->server, cfd, &v);
2238 if (r < 0)
2239 return 0;
2240
2241 TAKE_FD(cfd);
2242
2243 if (ss->server->connect_callback) {
2244 r = ss->server->connect_callback(ss->server, v, ss->server->userdata);
2245 if (r < 0) {
2246 varlink_log_errno(v, r, "Connection callback returned error, disconnecting client: %m");
2247 varlink_close(v);
2248 return 0;
2249 }
2250 }
2251
2252 return 0;
2253 }
2254
2255 static int varlink_server_create_listen_fd_socket(VarlinkServer *s, int fd, VarlinkServerSocket **ret_ss) {
2256 _cleanup_(varlink_server_socket_freep) VarlinkServerSocket *ss = NULL;
2257 int r;
2258
2259 assert(s);
2260 assert(fd >= 0);
2261 assert(ret_ss);
2262
2263 r = fd_nonblock(fd, true);
2264 if (r < 0)
2265 return r;
2266
2267 ss = new(VarlinkServerSocket, 1);
2268 if (!ss)
2269 return log_oom_debug();
2270
2271 *ss = (VarlinkServerSocket) {
2272 .server = s,
2273 .fd = fd,
2274 };
2275
2276 if (s->event) {
2277 r = sd_event_add_io(s->event, &ss->event_source, fd, EPOLLIN, connect_callback, ss);
2278 if (r < 0)
2279 return r;
2280
2281 r = sd_event_source_set_priority(ss->event_source, s->event_priority);
2282 if (r < 0)
2283 return r;
2284 }
2285
2286 *ret_ss = TAKE_PTR(ss);
2287 return 0;
2288 }
2289
2290 int varlink_server_listen_fd(VarlinkServer *s, int fd) {
2291 _cleanup_(varlink_server_socket_freep) VarlinkServerSocket *ss = NULL;
2292 int r;
2293
2294 assert_return(s, -EINVAL);
2295 assert_return(fd >= 0, -EBADF);
2296
2297 r = varlink_server_create_listen_fd_socket(s, fd, &ss);
2298 if (r < 0)
2299 return r;
2300
2301 LIST_PREPEND(sockets, s->sockets, TAKE_PTR(ss));
2302 return 0;
2303 }
2304
2305 int varlink_server_listen_address(VarlinkServer *s, const char *address, mode_t m) {
2306 _cleanup_(varlink_server_socket_freep) VarlinkServerSocket *ss = NULL;
2307 union sockaddr_union sockaddr;
2308 socklen_t sockaddr_len;
2309 _cleanup_close_ int fd = -1;
2310 int r;
2311
2312 assert_return(s, -EINVAL);
2313 assert_return(address, -EINVAL);
2314 assert_return((m & ~0777) == 0, -EINVAL);
2315
2316 r = sockaddr_un_set_path(&sockaddr.un, address);
2317 if (r < 0)
2318 return r;
2319 sockaddr_len = r;
2320
2321 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2322 if (fd < 0)
2323 return -errno;
2324
2325 fd = fd_move_above_stdio(fd);
2326
2327 (void) sockaddr_un_unlink(&sockaddr.un);
2328
2329 WITH_UMASK(~m & 0777) {
2330 r = mac_selinux_bind(fd, &sockaddr.sa, sockaddr_len);
2331 if (r < 0)
2332 return r;
2333 }
2334
2335 if (listen(fd, SOMAXCONN) < 0)
2336 return -errno;
2337
2338 r = varlink_server_create_listen_fd_socket(s, fd, &ss);
2339 if (r < 0)
2340 return r;
2341
2342 r = free_and_strdup(&ss->address, address);
2343 if (r < 0)
2344 return r;
2345
2346 LIST_PREPEND(sockets, s->sockets, TAKE_PTR(ss));
2347 TAKE_FD(fd);
2348 return 0;
2349 }
2350
2351 void* varlink_server_set_userdata(VarlinkServer *s, void *userdata) {
2352 void *ret;
2353
2354 assert_return(s, NULL);
2355
2356 ret = s->userdata;
2357 s->userdata = userdata;
2358
2359 return ret;
2360 }
2361
2362 void* varlink_server_get_userdata(VarlinkServer *s) {
2363 assert_return(s, NULL);
2364
2365 return s->userdata;
2366 }
2367
2368 static VarlinkServerSocket* varlink_server_socket_destroy(VarlinkServerSocket *ss) {
2369 if (!ss)
2370 return NULL;
2371
2372 if (ss->server)
2373 LIST_REMOVE(sockets, ss->server->sockets, ss);
2374
2375 sd_event_source_disable_unref(ss->event_source);
2376
2377 free(ss->address);
2378 safe_close(ss->fd);
2379
2380 return mfree(ss);
2381 }
2382
2383 int varlink_server_shutdown(VarlinkServer *s) {
2384 assert_return(s, -EINVAL);
2385
2386 while (s->sockets)
2387 varlink_server_socket_destroy(s->sockets);
2388
2389 return 0;
2390 }
2391
2392 static int varlink_server_add_socket_event_source(VarlinkServer *s, VarlinkServerSocket *ss, int64_t priority) {
2393 _cleanup_(sd_event_source_unrefp) sd_event_source *es = NULL;
2394
2395 int r;
2396
2397 assert(s);
2398 assert(s->event);
2399 assert(ss);
2400 assert(ss->fd >= 0);
2401 assert(!ss->event_source);
2402
2403 r = sd_event_add_io(s->event, &es, ss->fd, EPOLLIN, connect_callback, ss);
2404 if (r < 0)
2405 return r;
2406
2407 r = sd_event_source_set_priority(es, priority);
2408 if (r < 0)
2409 return r;
2410
2411 ss->event_source = TAKE_PTR(es);
2412 return 0;
2413 }
2414
2415 int varlink_server_attach_event(VarlinkServer *s, sd_event *e, int64_t priority) {
2416 int r;
2417
2418 assert_return(s, -EINVAL);
2419 assert_return(!s->event, -EBUSY);
2420
2421 if (e)
2422 s->event = sd_event_ref(e);
2423 else {
2424 r = sd_event_default(&s->event);
2425 if (r < 0)
2426 return r;
2427 }
2428
2429 LIST_FOREACH(sockets, ss, s->sockets) {
2430 r = varlink_server_add_socket_event_source(s, ss, priority);
2431 if (r < 0)
2432 goto fail;
2433 }
2434
2435 s->event_priority = priority;
2436 return 0;
2437
2438 fail:
2439 varlink_server_detach_event(s);
2440 return r;
2441 }
2442
2443 int varlink_server_detach_event(VarlinkServer *s) {
2444 assert_return(s, -EINVAL);
2445
2446 LIST_FOREACH(sockets, ss, s->sockets)
2447 ss->event_source = sd_event_source_disable_unref(ss->event_source);
2448
2449 sd_event_unref(s->event);
2450 return 0;
2451 }
2452
2453 sd_event *varlink_server_get_event(VarlinkServer *s) {
2454 assert_return(s, NULL);
2455
2456 return s->event;
2457 }
2458
2459 int varlink_server_bind_method(VarlinkServer *s, const char *method, VarlinkMethod callback) {
2460 _cleanup_free_ char *m = NULL;
2461 int r;
2462
2463 assert_return(s, -EINVAL);
2464 assert_return(method, -EINVAL);
2465 assert_return(callback, -EINVAL);
2466
2467 if (startswith(method, "org.varlink.service."))
2468 return log_debug_errno(SYNTHETIC_ERRNO(EEXIST), "Cannot bind server to '%s'.", method);
2469
2470 m = strdup(method);
2471 if (!m)
2472 return log_oom_debug();
2473
2474 r = hashmap_ensure_put(&s->methods, &string_hash_ops, m, callback);
2475 if (r == -ENOMEM)
2476 return log_oom_debug();
2477 if (r < 0)
2478 return log_debug_errno(r, "Failed to register callback: %m");
2479 if (r > 0)
2480 TAKE_PTR(m);
2481
2482 return 0;
2483 }
2484
2485 int varlink_server_bind_method_many_internal(VarlinkServer *s, ...) {
2486 va_list ap;
2487 int r = 0;
2488
2489 assert_return(s, -EINVAL);
2490
2491 va_start(ap, s);
2492 for (;;) {
2493 VarlinkMethod callback;
2494 const char *method;
2495
2496 method = va_arg(ap, const char *);
2497 if (!method)
2498 break;
2499
2500 callback = va_arg(ap, VarlinkMethod);
2501
2502 r = varlink_server_bind_method(s, method, callback);
2503 if (r < 0)
2504 break;
2505 }
2506 va_end(ap);
2507
2508 return r;
2509 }
2510
2511 int varlink_server_bind_connect(VarlinkServer *s, VarlinkConnect callback) {
2512 assert_return(s, -EINVAL);
2513
2514 if (callback && s->connect_callback && callback != s->connect_callback)
2515 return log_debug_errno(SYNTHETIC_ERRNO(EBUSY), "A different callback was already set.");
2516
2517 s->connect_callback = callback;
2518 return 0;
2519 }
2520
2521 int varlink_server_bind_disconnect(VarlinkServer *s, VarlinkDisconnect callback) {
2522 assert_return(s, -EINVAL);
2523
2524 if (callback && s->disconnect_callback && callback != s->disconnect_callback)
2525 return log_debug_errno(SYNTHETIC_ERRNO(EBUSY), "A different callback was already set.");
2526
2527 s->disconnect_callback = callback;
2528 return 0;
2529 }
2530
2531 unsigned varlink_server_connections_max(VarlinkServer *s) {
2532 int dts;
2533
2534 /* If a server is specified, return the setting for that server, otherwise the default value */
2535 if (s)
2536 return s->connections_max;
2537
2538 dts = getdtablesize();
2539 assert_se(dts > 0);
2540
2541 /* Make sure we never use up more than ¾th of RLIMIT_NOFILE for IPC */
2542 if (VARLINK_DEFAULT_CONNECTIONS_MAX > (unsigned) dts / 4 * 3)
2543 return dts / 4 * 3;
2544
2545 return VARLINK_DEFAULT_CONNECTIONS_MAX;
2546 }
2547
2548 unsigned varlink_server_connections_per_uid_max(VarlinkServer *s) {
2549 unsigned m;
2550
2551 if (s)
2552 return s->connections_per_uid_max;
2553
2554 /* Make sure to never use up more than ¾th of available connections for a single user */
2555 m = varlink_server_connections_max(NULL);
2556 if (VARLINK_DEFAULT_CONNECTIONS_PER_UID_MAX > m)
2557 return m / 4 * 3;
2558
2559 return VARLINK_DEFAULT_CONNECTIONS_PER_UID_MAX;
2560 }
2561
2562 int varlink_server_set_connections_per_uid_max(VarlinkServer *s, unsigned m) {
2563 assert_return(s, -EINVAL);
2564 assert_return(m > 0, -EINVAL);
2565
2566 s->connections_per_uid_max = m;
2567 return 0;
2568 }
2569
2570 int varlink_server_set_connections_max(VarlinkServer *s, unsigned m) {
2571 assert_return(s, -EINVAL);
2572 assert_return(m > 0, -EINVAL);
2573
2574 s->connections_max = m;
2575 return 0;
2576 }
2577
2578 unsigned varlink_server_current_connections(VarlinkServer *s) {
2579 assert_return(s, UINT_MAX);
2580
2581 return s->n_connections;
2582 }
2583
2584 int varlink_server_set_description(VarlinkServer *s, const char *description) {
2585 assert_return(s, -EINVAL);
2586
2587 return free_and_strdup(&s->description, description);
2588 }
2589
2590 int varlink_server_serialize(VarlinkServer *s, FILE *f, FDSet *fds) {
2591 assert(f);
2592 assert(fds);
2593
2594 if (!s)
2595 return 0;
2596
2597 LIST_FOREACH(sockets, ss, s->sockets) {
2598 int copy;
2599
2600 assert(ss->address);
2601 assert(ss->fd >= 0);
2602
2603 fprintf(f, "varlink-server-socket-address=%s", ss->address);
2604
2605 /* If we fail to serialize the fd, it will be considered an error during deserialization */
2606 copy = fdset_put_dup(fds, ss->fd);
2607 if (copy < 0)
2608 return copy;
2609
2610 fprintf(f, " varlink-server-socket-fd=%i", copy);
2611
2612 fputc('\n', f);
2613 }
2614
2615 return 0;
2616 }
2617
2618 int varlink_server_deserialize_one(VarlinkServer *s, const char *value, FDSet *fds) {
2619 _cleanup_(varlink_server_socket_freep) VarlinkServerSocket *ss = NULL;
2620 _cleanup_free_ char *address = NULL;
2621 const char *v = ASSERT_PTR(value);
2622 int r, fd = -1;
2623 char *buf;
2624 size_t n;
2625
2626 assert(s);
2627 assert(fds);
2628
2629 n = strcspn(v, " ");
2630 address = strndup(v, n);
2631 if (!address)
2632 return log_oom_debug();
2633
2634 if (v[n] != ' ')
2635 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
2636 "Failed to deserialize VarlinkServerSocket: %s: %m", value);
2637 v = startswith(v + n + 1, "varlink-server-socket-fd=");
2638 if (!v)
2639 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
2640 "Failed to deserialize VarlinkServerSocket fd %s: %m", value);
2641
2642 n = strcspn(v, " ");
2643 buf = strndupa_safe(v, n);
2644
2645 r = safe_atoi(buf, &fd);
2646 if (r < 0)
2647 return log_debug_errno(r, "Unable to parse VarlinkServerSocket varlink-server-socket-fd=%s: %m", buf);
2648
2649 if (!fdset_contains(fds, fd))
2650 return log_debug_errno(SYNTHETIC_ERRNO(EBADF),
2651 "VarlinkServerSocket varlink-server-socket-fd= has unknown fd %d: %m", fd);
2652
2653 ss = new(VarlinkServerSocket, 1);
2654 if (!ss)
2655 return log_oom_debug();
2656
2657 *ss = (VarlinkServerSocket) {
2658 .server = s,
2659 .address = TAKE_PTR(address),
2660 .fd = fdset_remove(fds, fd),
2661 };
2662
2663 r = varlink_server_add_socket_event_source(s, ss, SD_EVENT_PRIORITY_NORMAL);
2664 if (r < 0)
2665 return log_debug_errno(r, "Failed to add VarlinkServerSocket event source to the event loop: %m");
2666
2667 LIST_PREPEND(sockets, s->sockets, TAKE_PTR(ss));
2668 return 0;
2669 }
Unnamed repository; edit this file 'description' to name the repository.