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