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