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