]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/bus-proxyd/bus-proxyd.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
bus: always explicitly close bus from main programs
[thirdparty/systemd.git] / src / bus-proxyd / bus-proxyd.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7 Copyright 2013 Daniel Mack
8 Copyright 2014 Kay Sievers
9
10 systemd is free software; you can redistribute it and/or modify it
11 under the terms of the GNU Lesser General Public License as published by
12 the Free Software Foundation; either version 2.1 of the License, or
13 (at your option) any later version.
14
15 systemd is distributed in the hope that it will be useful, but
16 WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 Lesser General Public License for more details.
19
20 You should have received a copy of the GNU Lesser General Public License
21 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 ***/
23
24 #include <sys/socket.h>
25 #include <sys/un.h>
26 #include <sys/types.h>
27 #include <fcntl.h>
28 #include <unistd.h>
29 #include <string.h>
30 #include <errno.h>
31 #include <sys/poll.h>
32 #include <stddef.h>
33 #include <getopt.h>
34
35 #include "log.h"
36 #include "util.h"
37 #include "socket-util.h"
38 #include "sd-daemon.h"
39 #include "sd-bus.h"
40 #include "bus-internal.h"
41 #include "bus-message.h"
42 #include "bus-util.h"
43 #include "bus-internal.h"
44 #include "build.h"
45 #include "strv.h"
46 #include "def.h"
47 #include "capability.h"
48 #include "bus-policy.h"
49
50 static char *arg_address = NULL;
51 static char *arg_command_line_buffer = NULL;
52 static bool arg_drop_privileges = false;
53 static char **arg_configuration = NULL;
54
55 static int help(void) {
56
57 printf("%s [OPTIONS...]\n\n"
58 "Connect STDIO or a socket to a given bus address.\n\n"
59 " -h --help Show this help\n"
60 " --version Show package version\n"
61 " --drop-privileges Drop privileges\n"
62 " --configuration=PATH Configuration file or directory\n"
63 " --machine=MACHINE Connect to specified machine\n"
64 " --address=ADDRESS Connect to the bus specified by ADDRESS\n"
65 " (default: " DEFAULT_SYSTEM_BUS_PATH ")\n",
66 program_invocation_short_name);
67
68 return 0;
69 }
70
71 static int parse_argv(int argc, char *argv[]) {
72
73 enum {
74 ARG_VERSION = 0x100,
75 ARG_ADDRESS,
76 ARG_DROP_PRIVILEGES,
77 ARG_CONFIGURATION,
78 ARG_MACHINE,
79 };
80
81 static const struct option options[] = {
82 { "help", no_argument, NULL, 'h' },
83 { "version", no_argument, NULL, ARG_VERSION },
84 { "address", required_argument, NULL, ARG_ADDRESS },
85 { "drop-privileges", no_argument, NULL, ARG_DROP_PRIVILEGES },
86 { "configuration", required_argument, NULL, ARG_CONFIGURATION },
87 { "machine", required_argument, NULL, ARG_MACHINE },
88 {},
89 };
90
91 int c, r;
92
93 assert(argc >= 0);
94 assert(argv);
95
96 while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
97
98 switch (c) {
99
100 case 'h':
101 help();
102 return 0;
103
104 case ARG_VERSION:
105 puts(PACKAGE_STRING);
106 puts(SYSTEMD_FEATURES);
107 return 0;
108
109 case ARG_ADDRESS: {
110 char *a;
111
112 a = strdup(optarg);
113 if (!a)
114 return log_oom();
115
116 free(arg_address);
117 arg_address = a;
118 break;
119 }
120
121 case ARG_DROP_PRIVILEGES:
122 arg_drop_privileges = true;
123 break;
124
125 case ARG_CONFIGURATION:
126 r = strv_extend(&arg_configuration, optarg);
127 if (r < 0)
128 return log_oom();
129 break;
130
131 case ARG_MACHINE: {
132 _cleanup_free_ char *e = NULL;
133 char *a;
134
135 e = bus_address_escape(optarg);
136 if (!e)
137 return log_oom();
138
139 #ifdef ENABLE_KDBUS
140 a = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL);
141 #else
142 a = strjoin("x-container-unix:machine=", e, NULL);
143 #endif
144 if (!a)
145 return log_oom();
146
147 free(arg_address);
148 arg_address = a;
149
150 break;
151 }
152
153 case '?':
154 return -EINVAL;
155
156 default:
157 assert_not_reached("Unhandled option");
158 }
159
160 /* If the first command line argument is only "x" characters
161 * we'll write who we are talking to into it, so that "ps" is
162 * explanatory */
163 arg_command_line_buffer = argv[optind];
164 if (argc > optind + 1 || (arg_command_line_buffer && !in_charset(arg_command_line_buffer, "x"))) {
165 log_error("Too many arguments");
166 return -EINVAL;
167 }
168
169 if (!arg_address) {
170 arg_address = strdup(DEFAULT_SYSTEM_BUS_PATH);
171 if (!arg_address)
172 return log_oom();
173 }
174
175 return 1;
176 }
177
178 static int rename_service(sd_bus *a, sd_bus *b) {
179 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
180 _cleanup_free_ char *p = NULL, *name = NULL;
181 const char *comm;
182 char **cmdline;
183 uid_t uid;
184 pid_t pid;
185 int r;
186
187 assert(a);
188 assert(b);
189
190 r = sd_bus_get_peer_creds(b, SD_BUS_CREDS_UID|SD_BUS_CREDS_PID|SD_BUS_CREDS_CMDLINE|SD_BUS_CREDS_COMM, &creds);
191 if (r < 0)
192 return r;
193
194 r = sd_bus_creds_get_uid(creds, &uid);
195 if (r < 0)
196 return r;
197
198 r = sd_bus_creds_get_pid(creds, &pid);
199 if (r < 0)
200 return r;
201
202 r = sd_bus_creds_get_cmdline(creds, &cmdline);
203 if (r < 0)
204 return r;
205
206 r = sd_bus_creds_get_comm(creds, &comm);
207 if (r < 0)
208 return r;
209
210 name = uid_to_name(uid);
211 if (!name)
212 return -ENOMEM;
213
214 p = strv_join(cmdline, " ");
215 if (!p)
216 return -ENOMEM;
217
218 /* The status string gets the full command line ... */
219 sd_notifyf(false,
220 "STATUS=Processing requests from client PID "PID_FMT" (%s); UID "UID_FMT" (%s)",
221 pid, p,
222 uid, name);
223
224 /* ... and the argv line only the short comm */
225 if (arg_command_line_buffer) {
226 size_t m, w;
227
228 m = strlen(arg_command_line_buffer);
229 w = snprintf(arg_command_line_buffer, m,
230 "[PID "PID_FMT"/%s; UID "UID_FMT"/%s]",
231 pid, comm,
232 uid, name);
233
234 if (m > w)
235 memzero(arg_command_line_buffer + w, m - w);
236 }
237
238 log_debug("Running on behalf of PID "PID_FMT" (%s), UID "UID_FMT" (%s), %s",
239 pid, p,
240 uid, name,
241 a->unique_name);
242 ;
243 return 0;
244 }
245
246 static int synthesize_name_acquired(sd_bus *a, sd_bus *b, sd_bus_message *m) {
247 _cleanup_bus_message_unref_ sd_bus_message *n = NULL;
248 const char *name, *old_owner, *new_owner;
249 int r;
250
251 assert(a);
252 assert(b);
253 assert(m);
254
255 /* If we get NameOwnerChanged for our own name, we need to
256 * synthesize NameLost/NameAcquired, since socket clients need
257 * that, even though it is obsoleted on kdbus */
258
259 if (!a->is_kernel)
260 return 0;
261
262 if (!sd_bus_message_is_signal(m, "org.freedesktop.DBus", "NameOwnerChanged") ||
263 !streq_ptr(m->path, "/org/freedesktop/DBus") ||
264 !streq_ptr(m->sender, "org.freedesktop.DBus"))
265 return 0;
266
267 r = sd_bus_message_read(m, "sss", &name, &old_owner, &new_owner);
268 if (r < 0)
269 return r;
270
271 r = sd_bus_message_rewind(m, true);
272 if (r < 0)
273 return r;
274
275 if (streq(old_owner, a->unique_name)) {
276
277 r = sd_bus_message_new_signal(
278 b,
279 &n,
280 "/org/freedesktop/DBus",
281 "org.freedesktop.DBus",
282 "NameLost");
283
284 } else if (streq(new_owner, a->unique_name)) {
285
286 r = sd_bus_message_new_signal(
287 b,
288 &n,
289 "/org/freedesktop/DBus",
290 "org.freedesktop.DBus",
291 "NameAcquired");
292 } else
293 return 0;
294
295 if (r < 0)
296 return r;
297
298 r = sd_bus_message_append(n, "s", name);
299 if (r < 0)
300 return r;
301
302 r = bus_message_append_sender(n, "org.freedesktop.DBus");
303 if (r < 0)
304 return r;
305
306 r = bus_seal_synthetic_message(b, n);
307 if (r < 0)
308 return r;
309
310 return sd_bus_send(b, n, NULL);
311 }
312
313 static int process_policy(sd_bus *a, sd_bus *b, sd_bus_message *m) {
314 _cleanup_bus_message_unref_ sd_bus_message *n = NULL;
315 int r;
316
317 assert(a);
318 assert(b);
319 assert(m);
320
321 if (!a->is_kernel)
322 return 0;
323
324 if (!sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Properties", "GetAll"))
325 return 0;
326
327 if (!streq_ptr(m->path, "/org/gnome/DisplayManager/Slave"))
328 return 0;
329
330 r = sd_bus_message_new_method_errorf(m, &n, SD_BUS_ERROR_ACCESS_DENIED, "gdm, you are stupid");
331 if (r < 0)
332 return r;
333
334 r = bus_message_append_sender(n, "org.freedesktop.DBus");
335 if (r < 0) {
336 log_error("Failed to append sender to gdm reply: %s", strerror(-r));
337 return r;
338 }
339
340 r = bus_seal_synthetic_message(b, n);
341 if (r < 0) {
342 log_error("Failed to seal gdm reply: %s", strerror(-r));
343 return r;
344 }
345
346 r = sd_bus_send(b, n, NULL);
347 if (r < 0) {
348 log_error("Failed to send gdm reply: %s", strerror(-r));
349 return r;
350 }
351
352 return 1;
353 }
354
355 static int synthetic_driver_send(sd_bus *b, sd_bus_message *m) {
356 int r;
357
358 assert(b);
359 assert(m);
360
361 r = bus_message_append_sender(m, "org.freedesktop.DBus");
362 if (r < 0)
363 return r;
364
365 r = bus_seal_synthetic_message(b, m);
366 if (r < 0)
367 return r;
368
369 return sd_bus_send(b, m, NULL);
370 }
371
372 static int synthetic_reply_method_error(sd_bus_message *call, const sd_bus_error *e) {
373 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
374 int r;
375
376 if (call->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
377 return 0;
378
379 r = sd_bus_message_new_method_error(call, &m, e);
380 if (r < 0)
381 return r;
382
383 return synthetic_driver_send(call->bus, m);
384 }
385
386 static int synthetic_reply_method_errno(sd_bus_message *call, int error, const sd_bus_error *p) {
387
388 _cleanup_bus_error_free_ sd_bus_error berror = SD_BUS_ERROR_NULL;
389
390 if (call->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
391 return 0;
392
393 if (sd_bus_error_is_set(p))
394 return synthetic_reply_method_error(call, p);
395
396 sd_bus_error_set_errno(&berror, error);
397
398 return synthetic_reply_method_error(call, &berror);
399 }
400
401 static int synthetic_reply_method_return(sd_bus_message *call, const char *types, ...) {
402 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
403 int r;
404
405 if (call->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
406 return 0;
407
408 r = sd_bus_message_new_method_return(call, &m);
409 if (r < 0)
410 return r;
411
412 if (!isempty(types)) {
413 va_list ap;
414
415 va_start(ap, types);
416 r = bus_message_append_ap(m, types, ap);
417 va_end(ap);
418 if (r < 0)
419 return r;
420 }
421
422 return synthetic_driver_send(call->bus, m);
423 }
424
425 static int synthetic_reply_return_strv(sd_bus_message *call, char **l) {
426 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
427 int r;
428
429 r = sd_bus_message_new_method_return(call, &m);
430 if (r < 0)
431 return synthetic_reply_method_errno(call, r, NULL);
432
433 r = sd_bus_message_append_strv(m, l);
434 if (r < 0)
435 return synthetic_reply_method_errno(call, r, NULL);
436
437 return synthetic_driver_send(call->bus, m);
438 }
439
440 static int get_creds_by_name(sd_bus *bus, const char *name, uint64_t mask, sd_bus_creds **_creds, sd_bus_error *error) {
441 _cleanup_bus_creds_unref_ sd_bus_creds *c = NULL;
442 int r;
443
444 assert(bus);
445 assert(name);
446 assert(_creds);
447
448 assert_return(service_name_is_valid(name), -EINVAL);
449
450 r = sd_bus_get_owner(bus, name, mask, &c);
451 if (r == -ESRCH || r == -ENXIO)
452 return sd_bus_error_setf(error, SD_BUS_ERROR_NAME_HAS_NO_OWNER, "Name %s is currently not owned by anyone.", name);
453 if (r < 0)
454 return r;
455
456 if ((c->mask & mask) != mask)
457 return -ENOTSUP;
458
459 *_creds = c;
460 c = NULL;
461
462 return 0;
463 }
464
465 static int get_creds_by_message(sd_bus *bus, sd_bus_message *m, uint64_t mask, sd_bus_creds **_creds, sd_bus_error *error) {
466 const char *name;
467 int r;
468
469 assert(bus);
470 assert(m);
471 assert(_creds);
472
473 r = sd_bus_message_read(m, "s", &name);
474 if (r < 0)
475 return r;
476
477 return get_creds_by_name(bus, name, mask, _creds, error);
478 }
479
480 static int peer_is_privileged(sd_bus *bus, sd_bus_message *m) {
481 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
482 uid_t uid;
483 int r;
484
485 r = get_creds_by_message(bus, m, SD_BUS_CREDS_UID, &creds, NULL);
486 if (r < 0)
487 return r;
488
489 r = sd_bus_creds_get_uid(creds, &uid);
490 if (r < 0)
491 return r;
492
493 r = sd_bus_creds_has_effective_cap(creds, CAP_SYS_ADMIN);
494 if (r > 0)
495 return true;
496
497 if (uid == getuid())
498 return true;
499
500 return false;
501 }
502
503 static int process_driver(sd_bus *a, sd_bus *b, sd_bus_message *m) {
504 int r;
505
506 assert(a);
507 assert(b);
508 assert(m);
509
510 if (!a->is_kernel)
511 return 0;
512
513 if (!streq_ptr(sd_bus_message_get_destination(m), "org.freedesktop.DBus"))
514 return 0;
515
516 if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
517 if (0 && !isempty(sd_bus_message_get_signature(m, true))) {
518 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
519
520 r = sd_bus_error_setf(&error, SD_BUS_ERROR_INVALID_ARGS, "Expected no parameters");
521
522 return synthetic_reply_method_errno(m, r, &error);
523 }
524
525 return synthetic_reply_method_return(m, "s",
526 "<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\" "
527 "\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n"
528 "<node>\n"
529 " <interface name=\"org.freedesktop.DBus.Introspectable\">\n"
530 " <method name=\"Introspect\">\n"
531 " <arg name=\"data\" type=\"s\" direction=\"out\"/>\n"
532 " </method>\n"
533 " </interface>\n"
534 " <interface name=\"org.freedesktop.DBus\">\n"
535 " <method name=\"AddMatch\">\n"
536 " <arg type=\"s\" direction=\"in\"/>\n"
537 " </method>\n"
538 " <method name=\"RemoveMatch\">\n"
539 " <arg type=\"s\" direction=\"in\"/>\n"
540 " </method>\n"
541 " <method name=\"GetConnectionSELinuxSecurityContext\">\n"
542 " <arg type=\"s\" direction=\"in\"/>\n"
543 " <arg type=\"ay\" direction=\"out\"/>\n"
544 " </method>\n"
545 " <method name=\"GetConnectionUnixProcessID\">\n"
546 " <arg type=\"s\" direction=\"in\"/>\n"
547 " <arg type=\"u\" direction=\"out\"/>\n"
548 " </method>\n"
549 " <method name=\"GetConnectionUnixUser\">\n"
550 " <arg type=\"s\" direction=\"in\"/>\n"
551 " <arg type=\"u\" direction=\"out\"/>\n"
552 " </method>\n"
553 " <method name=\"GetId\">\n"
554 " <arg type=\"s\" direction=\"out\"/>\n"
555 " </method>\n"
556 " <method name=\"GetNameOwner\">\n"
557 " <arg type=\"s\" direction=\"in\"/>\n"
558 " <arg type=\"s\" direction=\"out\"/>\n"
559 " </method>\n"
560 " <method name=\"Hello\">\n"
561 " <arg type=\"s\" direction=\"out\"/>\n"
562 " </method>\n"
563 " <method name=\"ListActivatableNames\">\n"
564 " <arg type=\"as\" direction=\"out\"/>\n"
565 " </method>\n"
566 " <method name=\"ListNames\">\n"
567 " <arg type=\"as\" direction=\"out\"/>\n"
568 " </method>\n"
569 " <method name=\"ListQueuedOwners\">\n"
570 " <arg type=\"s\" direction=\"in\"/>\n"
571 " <arg type=\"as\" direction=\"out\"/>\n"
572 " </method>\n"
573 " <method name=\"NameHasOwner\">\n"
574 " <arg type=\"s\" direction=\"in\"/>\n"
575 " <arg type=\"b\" direction=\"out\"/>\n"
576 " </method>\n"
577 " <method name=\"ReleaseName\">\n"
578 " <arg type=\"s\" direction=\"in\"/>\n"
579 " <arg type=\"u\" direction=\"out\"/>\n"
580 " </method>\n"
581 " <method name=\"ReloadConfig\">\n"
582 " </method>\n"
583 " <method name=\"RequestName\">\n"
584 " <arg type=\"s\" direction=\"in\"/>\n"
585 " <arg type=\"u\" direction=\"in\"/>\n"
586 " <arg type=\"u\" direction=\"out\"/>\n"
587 " </method>\n"
588 " <method name=\"StartServiceByName\">\n"
589 " <arg type=\"s\" direction=\"in\"/>\n"
590 " <arg type=\"u\" direction=\"in\"/>\n"
591 " <arg type=\"u\" direction=\"out\"/>\n"
592 " </method>\n"
593 " <method name=\"UpdateActivationEnvironment\">\n"
594 " <arg type=\"a{ss}\" direction=\"in\"/>\n"
595 " </method>\n"
596 " <signal name=\"NameAcquired\">\n"
597 " <arg type=\"s\"/>\n"
598 " </signal>\n"
599 " <signal name=\"NameLost\">\n"
600 " <arg type=\"s\"/>\n"
601 " </signal>\n"
602 " <signal name=\"NameOwnerChanged\">\n"
603 " <arg type=\"s\"/>\n"
604 " <arg type=\"s\"/>\n"
605 " <arg type=\"s\"/>\n"
606 " </signal>\n"
607 " </interface>\n"
608 "</node>\n");
609
610 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "AddMatch")) {
611 const char *match;
612
613 r = sd_bus_message_read(m, "s", &match);
614 if (r < 0)
615 return synthetic_reply_method_errno(m, r, NULL);
616
617 r = sd_bus_add_match(a, NULL, match, NULL, NULL);
618 if (r < 0)
619 return synthetic_reply_method_errno(m, r, NULL);
620
621 return synthetic_reply_method_return(m, NULL);
622
623 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "RemoveMatch")) {
624 const char *match;
625
626 r = sd_bus_message_read(m, "s", &match);
627 if (r < 0)
628 return synthetic_reply_method_errno(m, r, NULL);
629
630 r = bus_remove_match_by_string(a, match, NULL, NULL);
631 if (r == 0)
632 return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_MATCH_RULE_NOT_FOUND, "Match rule not found"));
633 if (r < 0)
634 return synthetic_reply_method_errno(m, r, NULL);
635
636 return synthetic_reply_method_return(m, NULL);
637
638 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "GetConnectionSELinuxSecurityContext")) {
639 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
640
641 r = get_creds_by_message(a, m, SD_BUS_CREDS_SELINUX_CONTEXT, &creds, NULL);
642 if (r < 0)
643 return synthetic_reply_method_errno(m, r, NULL);
644
645 return synthetic_reply_method_return(m, "y", creds->label, strlen(creds->label));
646
647 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "GetConnectionUnixProcessID")) {
648 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
649
650 r = get_creds_by_message(a, m, SD_BUS_CREDS_PID, &creds, NULL);
651 if (r < 0)
652 return synthetic_reply_method_errno(m, r, NULL);
653
654 return synthetic_reply_method_return(m, "u", (uint32_t) creds->pid);
655
656 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "GetConnectionUnixUser")) {
657 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
658
659 r = get_creds_by_message(a, m, SD_BUS_CREDS_UID, &creds, NULL);
660 if (r < 0)
661 return synthetic_reply_method_errno(m, r, NULL);
662
663 return synthetic_reply_method_return(m, "u", (uint32_t) creds->uid);
664
665 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "GetId")) {
666 sd_id128_t server_id;
667 char buf[SD_ID128_STRING_MAX];
668
669 r = sd_bus_get_server_id(a, &server_id);
670 if (r < 0)
671 return synthetic_reply_method_errno(m, r, NULL);
672
673 return synthetic_reply_method_return(m, "s", sd_id128_to_string(server_id, buf));
674
675 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "GetNameOwner")) {
676 const char *name;
677 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
678 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
679
680 r = sd_bus_message_read(m, "s", &name);
681 if (r < 0)
682 return synthetic_reply_method_errno(m, r, NULL);
683
684 if (streq(name, "org.freedesktop.DBus"))
685 return synthetic_reply_method_return(m, "s", "org.freedesktop.DBus");
686
687 r = get_creds_by_name(a, name, SD_BUS_CREDS_UNIQUE_NAME, &creds, &error);
688 if (r < 0)
689 return synthetic_reply_method_errno(m, r, &error);
690
691 return synthetic_reply_method_return(m, "s", creds->unique_name);
692
693 /* "Hello" is handled in process_hello() */
694
695 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ListActivatableNames")) {
696 _cleanup_strv_free_ char **names = NULL;
697
698 r = sd_bus_list_names(a, NULL, &names);
699 if (r < 0)
700 return synthetic_reply_method_errno(m, r, NULL);
701
702 /* Let's sort the names list to make it stable */
703 strv_sort(names);
704
705 return synthetic_reply_return_strv(m, names);
706
707 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ListNames")) {
708 _cleanup_strv_free_ char **names = NULL;
709
710 r = sd_bus_list_names(a, &names, NULL);
711 if (r < 0)
712 return synthetic_reply_method_errno(m, r, NULL);
713
714 r = strv_extend(&names, "org.freedesktop.DBus");
715 if (r < 0)
716 return synthetic_reply_method_errno(m, r, NULL);
717
718 /* Let's sort the names list to make it stable */
719 strv_sort(names);
720
721 return synthetic_reply_return_strv(m, names);
722
723 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ListQueuedOwners")) {
724 struct kdbus_cmd_name_list cmd = {};
725 struct kdbus_name_list *name_list;
726 struct kdbus_cmd_name *name;
727 _cleanup_strv_free_ char **owners = NULL;
728 char *arg0;
729 int err = 0;
730
731 r = sd_bus_message_read(m, "s", &arg0);
732 if (r < 0)
733 return synthetic_reply_method_errno(m, r, NULL);
734
735 if (service_name_is_valid(arg0) < 0)
736 return synthetic_reply_method_errno(m, -EINVAL, NULL);
737
738 cmd.flags = KDBUS_NAME_LIST_QUEUED;
739 r = ioctl(a->input_fd, KDBUS_CMD_NAME_LIST, &cmd);
740 if (r < 0)
741 return synthetic_reply_method_errno(m, -errno, NULL);
742
743 name_list = (struct kdbus_name_list *) ((uint8_t *) a->kdbus_buffer + cmd.offset);
744
745 KDBUS_ITEM_FOREACH(name, name_list, names) {
746 char *n;
747
748 if (name->size <= sizeof(*name))
749 continue;
750
751 if (!streq(name->name, arg0))
752 continue;
753
754 if (asprintf(&n, ":1.%llu", (unsigned long long) name->owner_id) < 0) {
755 err = -ENOMEM;
756 break;
757 }
758
759 r = strv_consume(&owners, n);
760 if (r < 0) {
761 err = r;
762 break;
763 }
764 }
765
766 r = ioctl(a->input_fd, KDBUS_CMD_FREE, &cmd.offset);
767 if (r < 0)
768 return synthetic_reply_method_errno(m, r, NULL);
769
770 if (err < 0)
771 return synthetic_reply_method_errno(m, err, NULL);
772
773 return synthetic_reply_return_strv(m, owners);
774
775 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "NameHasOwner")) {
776 const char *name;
777
778 r = sd_bus_message_read(m, "s", &name);
779 if (r < 0)
780 return synthetic_reply_method_errno(m, r, NULL);
781
782 if (service_name_is_valid(name) < 0)
783 return synthetic_reply_method_errno(m, -EINVAL, NULL);
784
785 if (streq(name, "org.freedesktop.DBus"))
786 return synthetic_reply_method_return(m, "b", true);
787
788 r = sd_bus_get_owner(a, name, 0, NULL);
789 if (r < 0 && r != -ESRCH && r != -ENXIO)
790 return synthetic_reply_method_errno(m, r, NULL);
791
792 return synthetic_reply_method_return(m, "b", r >= 0);
793
794 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ReleaseName")) {
795 const char *name;
796
797 r = sd_bus_message_read(m, "s", &name);
798 if (r < 0)
799 return synthetic_reply_method_errno(m, r, NULL);
800
801 if (service_name_is_valid(name) < 0)
802 return synthetic_reply_method_errno(m, -EINVAL, NULL);
803
804 r = sd_bus_release_name(a, name);
805 if (r < 0) {
806 if (r == -ESRCH)
807 return synthetic_reply_method_return(m, "u", BUS_NAME_NON_EXISTENT);
808 if (r == -EADDRINUSE)
809 return synthetic_reply_method_return(m, "u", BUS_NAME_NOT_OWNER);
810
811 return synthetic_reply_method_errno(m, r, NULL);
812 }
813
814 return synthetic_reply_method_return(m, "u", BUS_NAME_RELEASED);
815
816 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ReloadConfig")) {
817 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
818
819 r = sd_bus_error_setf(&error, SD_BUS_ERROR_NOT_SUPPORTED, "%s() is not supported", sd_bus_message_get_member(m));
820
821 return synthetic_reply_method_errno(m, r, &error);
822
823 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "RequestName")) {
824 const char *name;
825 uint32_t flags;
826
827 r = sd_bus_message_read(m, "su", &name, &flags);
828 if (r < 0)
829 return synthetic_reply_method_errno(m, r, NULL);
830
831 if (service_name_is_valid(name) < 0)
832 return synthetic_reply_method_errno(m, -EINVAL, NULL);
833 if ((flags & ~(BUS_NAME_ALLOW_REPLACEMENT|BUS_NAME_REPLACE_EXISTING|BUS_NAME_DO_NOT_QUEUE)) != 0)
834 return synthetic_reply_method_errno(m, -EINVAL, NULL);
835
836 r = sd_bus_request_name(a, name, flags);
837 if (r < 0) {
838 if (r == -EEXIST)
839 return synthetic_reply_method_return(m, "u", BUS_NAME_EXISTS);
840 if (r == -EALREADY)
841 return synthetic_reply_method_return(m, "u", BUS_NAME_ALREADY_OWNER);
842 return synthetic_reply_method_errno(m, r, NULL);
843 }
844
845 if (r == 0)
846 return synthetic_reply_method_return(m, "u", BUS_NAME_IN_QUEUE);
847
848 return synthetic_reply_method_return(m, "u", BUS_NAME_PRIMARY_OWNER);
849
850 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "StartServiceByName")) {
851 _cleanup_bus_message_unref_ sd_bus_message *msg = NULL;
852 const char *name;
853 uint32_t flags;
854
855 r = sd_bus_message_read(m, "su", &name, &flags);
856 if (r < 0)
857 return synthetic_reply_method_errno(m, r, NULL);
858
859 if (service_name_is_valid(name) < 0)
860 return synthetic_reply_method_errno(m, -EINVAL, NULL);
861 if (flags != 0)
862 return synthetic_reply_method_errno(m, -EINVAL, NULL);
863
864 r = sd_bus_get_owner(a, name, 0, NULL);
865 if (r >= 0 || streq(name, "org.freedesktop.DBus"))
866 return synthetic_reply_method_return(m, "u", BUS_START_REPLY_ALREADY_RUNNING);
867 if (r != -ESRCH)
868 return synthetic_reply_method_errno(m, r, NULL);
869
870 r = sd_bus_message_new_method_call(
871 a,
872 &msg,
873 name,
874 "/",
875 "org.freedesktop.DBus.Peer",
876 "Ping");
877 if (r < 0)
878 return synthetic_reply_method_errno(m, r, NULL);
879
880 r = sd_bus_send(a, msg, NULL);
881 if (r < 0)
882 return synthetic_reply_method_errno(m, r, NULL);
883
884 return synthetic_reply_method_return(m, "u", BUS_START_REPLY_SUCCESS);
885
886 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "UpdateActivationEnvironment")) {
887 _cleanup_bus_message_unref_ sd_bus_message *msg = NULL;
888 _cleanup_strv_free_ char **args = NULL;
889
890 if (!peer_is_privileged(a, m))
891 return synthetic_reply_method_errno(m, -EPERM, NULL);
892
893 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "{ss}");
894 if (r < 0)
895 return synthetic_reply_method_errno(m, r, NULL);
896
897 while ((r = sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY, "ss")) > 0) {
898 _cleanup_free_ char *s = NULL;
899 const char *key;
900 const char *value;
901
902 r = sd_bus_message_read(m, "ss", &key, &value);
903 if (r < 0)
904 return synthetic_reply_method_errno(m, r, NULL);
905
906 s = strjoin(key, "=", value, NULL);
907 if (!s)
908 return synthetic_reply_method_errno(m, -ENOMEM, NULL);
909
910 r = strv_extend(&args, s);
911 if (r < 0)
912 return synthetic_reply_method_errno(m, r, NULL);
913
914 r = sd_bus_message_exit_container(m);
915 if (r < 0)
916 return synthetic_reply_method_errno(m, r, NULL);
917 }
918
919 r = sd_bus_message_exit_container(m);
920 if (r < 0)
921 return synthetic_reply_method_errno(m, r, NULL);
922
923 if (!args)
924 return synthetic_reply_method_errno(m, -EINVAL, NULL);
925
926 r = sd_bus_message_new_method_call(
927 a,
928 &msg,
929 "org.freedesktop.systemd1",
930 "/org/freedesktop/systemd1",
931 "org.freedesktop.systemd1.Manager",
932 "SetEnvironment");
933 if (r < 0)
934 return synthetic_reply_method_errno(m, r, NULL);
935
936 r = sd_bus_message_append_strv(msg, args);
937 if (r < 0)
938 return synthetic_reply_method_errno(m, r, NULL);
939
940 r = sd_bus_call(a, msg, 0, NULL, NULL);
941 if (r < 0)
942 return synthetic_reply_method_errno(m, r, NULL);
943
944 return synthetic_reply_method_return(m, NULL);
945
946 } else {
947 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
948
949 r = sd_bus_error_setf(&error, SD_BUS_ERROR_UNKNOWN_METHOD, "Unknown method '%s'.", m->member);
950
951 return synthetic_reply_method_errno(m, r, &error);
952 }
953 }
954
955 static int process_hello(sd_bus *a, sd_bus *b, sd_bus_message *m, bool *got_hello) {
956 _cleanup_bus_message_unref_ sd_bus_message *n = NULL;
957 bool is_hello;
958 int r;
959
960 assert(a);
961 assert(b);
962 assert(m);
963 assert(got_hello);
964
965 /* As reaction to hello we need to respond with two messages:
966 * the callback reply and the NameAcquired for the unique
967 * name, since hello is otherwise obsolete on kdbus. */
968
969 is_hello =
970 sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "Hello") &&
971 streq_ptr(m->destination, "org.freedesktop.DBus");
972
973 if (!is_hello) {
974
975 if (*got_hello)
976 return 0;
977
978 log_error("First packet isn't hello (it's %s.%s), aborting.", m->interface, m->member);
979 return -EIO;
980 }
981
982 if (*got_hello) {
983 log_error("Got duplicate hello, aborting.");
984 return -EIO;
985 }
986
987 *got_hello = true;
988
989 if (!a->is_kernel)
990 return 0;
991
992 r = sd_bus_message_new_method_return(m, &n);
993 if (r < 0) {
994 log_error("Failed to generate HELLO reply: %s", strerror(-r));
995 return r;
996 }
997
998 r = sd_bus_message_append(n, "s", a->unique_name);
999 if (r < 0) {
1000 log_error("Failed to append unique name to HELLO reply: %s", strerror(-r));
1001 return r;
1002 }
1003
1004 r = bus_message_append_sender(n, "org.freedesktop.DBus");
1005 if (r < 0) {
1006 log_error("Failed to append sender to HELLO reply: %s", strerror(-r));
1007 return r;
1008 }
1009
1010 r = bus_seal_synthetic_message(b, n);
1011 if (r < 0) {
1012 log_error("Failed to seal HELLO reply: %s", strerror(-r));
1013 return r;
1014 }
1015
1016 r = sd_bus_send(b, n, NULL);
1017 if (r < 0) {
1018 log_error("Failed to send HELLO reply: %s", strerror(-r));
1019 return r;
1020 }
1021
1022 n = sd_bus_message_unref(n);
1023 r = sd_bus_message_new_signal(
1024 b,
1025 &n,
1026 "/org/freedesktop/DBus",
1027 "org.freedesktop.DBus",
1028 "NameAcquired");
1029 if (r < 0) {
1030 log_error("Failed to allocate initial NameAcquired message: %s", strerror(-r));
1031 return r;
1032 }
1033
1034 r = sd_bus_message_append(n, "s", a->unique_name);
1035 if (r < 0) {
1036 log_error("Failed to append unique name to NameAcquired message: %s", strerror(-r));
1037 return r;
1038 }
1039
1040 r = bus_message_append_sender(n, "org.freedesktop.DBus");
1041 if (r < 0) {
1042 log_error("Failed to append sender to NameAcquired message: %s", strerror(-r));
1043 return r;
1044 }
1045
1046 r = bus_seal_synthetic_message(b, n);
1047 if (r < 0) {
1048 log_error("Failed to seal NameAcquired message: %s", strerror(-r));
1049 return r;
1050 }
1051
1052 r = sd_bus_send(b, n, NULL);
1053 if (r < 0) {
1054 log_error("Failed to send NameAcquired message: %s", strerror(-r));
1055 return r;
1056 }
1057
1058 return 1;
1059 }
1060
1061 static int patch_sender(sd_bus *a, sd_bus_message *m) {
1062 char **well_known = NULL;
1063 sd_bus_creds *c;
1064 int r;
1065
1066 assert(a);
1067 assert(m);
1068
1069 if (!a->is_kernel)
1070 return 0;
1071
1072 /* We will change the sender of messages from the bus driver
1073 * so that they originate from the bus driver. This is a
1074 * speciality originating from dbus1, where the bus driver did
1075 * not have a unique id, but only the well-known name. */
1076
1077 c = sd_bus_message_get_creds(m);
1078 if (!c)
1079 return 0;
1080
1081 r = sd_bus_creds_get_well_known_names(c, &well_known);
1082 if (r < 0)
1083 return r;
1084
1085 if (strv_contains(well_known, "org.freedesktop.DBus"))
1086 m->sender = "org.freedesktop.DBus";
1087
1088 return 0;
1089 }
1090
1091 int main(int argc, char *argv[]) {
1092
1093 _cleanup_bus_close_unref_ sd_bus *a = NULL, *b = NULL;
1094 sd_id128_t server_id;
1095 int r, in_fd, out_fd;
1096 bool got_hello = false;
1097 bool is_unix;
1098 struct ucred ucred = {};
1099 _cleanup_free_ char *peersec = NULL;
1100 Policy policy = {};
1101
1102 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1103 log_parse_environment();
1104 log_open();
1105
1106 r = parse_argv(argc, argv);
1107 if (r <= 0)
1108 goto finish;
1109
1110 r = policy_load(&policy, arg_configuration);
1111 if (r < 0) {
1112 log_error("Failed to load policy: %s", strerror(-r));
1113 goto finish;
1114 }
1115
1116 /* policy_dump(&policy); */
1117
1118 r = sd_listen_fds(0);
1119 if (r == 0) {
1120 in_fd = STDIN_FILENO;
1121 out_fd = STDOUT_FILENO;
1122 } else if (r == 1) {
1123 in_fd = SD_LISTEN_FDS_START;
1124 out_fd = SD_LISTEN_FDS_START;
1125 } else {
1126 log_error("Illegal number of file descriptors passed");
1127 goto finish;
1128 }
1129
1130 is_unix =
1131 sd_is_socket(in_fd, AF_UNIX, 0, 0) > 0 &&
1132 sd_is_socket(out_fd, AF_UNIX, 0, 0) > 0;
1133
1134 if (is_unix) {
1135 getpeercred(in_fd, &ucred);
1136 getpeersec(in_fd, &peersec);
1137 }
1138
1139 if (arg_drop_privileges) {
1140 const char *user = "systemd-bus-proxy";
1141 uid_t uid;
1142 gid_t gid;
1143
1144 r = get_user_creds(&user, &uid, &gid, NULL, NULL);
1145 if (r < 0) {
1146 log_error("Cannot resolve user name %s: %s", user, strerror(-r));
1147 goto finish;
1148 }
1149
1150 r = drop_privileges(uid, gid, 1ULL << CAP_IPC_OWNER);
1151 if (r < 0)
1152 goto finish;
1153 }
1154
1155 r = sd_bus_new(&a);
1156 if (r < 0) {
1157 log_error("Failed to allocate bus: %s", strerror(-r));
1158 goto finish;
1159 }
1160
1161 r = sd_bus_set_name(a, "sd-proxy");
1162 if (r < 0) {
1163 log_error("Failed to set bus name: %s", strerror(-r));
1164 goto finish;
1165 }
1166
1167 r = sd_bus_set_address(a, arg_address);
1168 if (r < 0) {
1169 log_error("Failed to set address to connect to: %s", strerror(-r));
1170 goto finish;
1171 }
1172
1173 r = sd_bus_negotiate_fds(a, is_unix);
1174 if (r < 0) {
1175 log_error("Failed to set FD negotiation: %s", strerror(-r));
1176 goto finish;
1177 }
1178
1179 if (ucred.pid > 0) {
1180 a->fake_creds.pid = ucred.pid;
1181 a->fake_creds.uid = ucred.uid;
1182 a->fake_creds.gid = ucred.gid;
1183 a->fake_creds_valid = true;
1184 }
1185
1186 if (peersec) {
1187 a->fake_label = peersec;
1188 peersec = NULL;
1189 }
1190
1191 a->manual_peer_interface = true;
1192
1193 r = sd_bus_start(a);
1194 if (r < 0) {
1195 log_error("Failed to start bus client: %s", strerror(-r));
1196 goto finish;
1197 }
1198
1199 r = sd_bus_get_server_id(a, &server_id);
1200 if (r < 0) {
1201 log_error("Failed to get server ID: %s", strerror(-r));
1202 goto finish;
1203 }
1204
1205 r = sd_bus_new(&b);
1206 if (r < 0) {
1207 log_error("Failed to allocate bus: %s", strerror(-r));
1208 goto finish;
1209 }
1210
1211 r = sd_bus_set_fd(b, in_fd, out_fd);
1212 if (r < 0) {
1213 log_error("Failed to set fds: %s", strerror(-r));
1214 goto finish;
1215 }
1216
1217 r = sd_bus_set_server(b, 1, server_id);
1218 if (r < 0) {
1219 log_error("Failed to set server mode: %s", strerror(-r));
1220 goto finish;
1221 }
1222
1223 r = sd_bus_negotiate_fds(b, is_unix);
1224 if (r < 0) {
1225 log_error("Failed to set FD negotiation: %s", strerror(-r));
1226 goto finish;
1227 }
1228
1229 r = sd_bus_set_anonymous(b, true);
1230 if (r < 0) {
1231 log_error("Failed to set anonymous authentication: %s", strerror(-r));
1232 goto finish;
1233 }
1234
1235 b->manual_peer_interface = true;
1236
1237 r = sd_bus_start(b);
1238 if (r < 0) {
1239 log_error("Failed to start bus client: %s", strerror(-r));
1240 goto finish;
1241 }
1242
1243 r = rename_service(a, b);
1244 if (r < 0)
1245 log_debug("Failed to rename process: %s", strerror(-r));
1246
1247 if (a->is_kernel) {
1248 _cleanup_free_ char *match = NULL;
1249 const char *unique;
1250
1251 r = sd_bus_get_unique_name(a, &unique);
1252 if (r < 0) {
1253 log_error("Failed to get unique name: %s", strerror(-r));
1254 goto finish;
1255 }
1256
1257 match = strjoin("type='signal',"
1258 "sender='org.freedesktop.DBus',"
1259 "path='/org/freedesktop/DBus',"
1260 "interface='org.freedesktop.DBus',"
1261 "member='NameOwnerChanged',"
1262 "arg1='",
1263 unique,
1264 "'",
1265 NULL);
1266 if (!match) {
1267 log_oom();
1268 goto finish;
1269 }
1270
1271 r = sd_bus_add_match(a, NULL, match, NULL, NULL);
1272 if (r < 0) {
1273 log_error("Failed to add match for NameLost: %s", strerror(-r));
1274 goto finish;
1275 }
1276
1277 free(match);
1278 match = strjoin("type='signal',"
1279 "sender='org.freedesktop.DBus',"
1280 "path='/org/freedesktop/DBus',"
1281 "interface='org.freedesktop.DBus',"
1282 "member='NameOwnerChanged',"
1283 "arg2='",
1284 unique,
1285 "'",
1286 NULL);
1287 if (!match) {
1288 log_oom();
1289 goto finish;
1290 }
1291
1292 r = sd_bus_add_match(a, NULL, match, NULL, NULL);
1293 if (r < 0) {
1294 log_error("Failed to add match for NameAcquired: %s", strerror(-r));
1295 goto finish;
1296 }
1297 }
1298
1299 for (;;) {
1300 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1301 int events_a, events_b, fd;
1302 uint64_t timeout_a, timeout_b, t;
1303 struct timespec _ts, *ts;
1304 struct pollfd *pollfd;
1305 int k;
1306
1307 if (got_hello) {
1308 r = sd_bus_process(a, &m);
1309 if (r < 0) {
1310 /* treat 'connection reset by peer' as clean exit condition */
1311 if (r == -ECONNRESET)
1312 r = 0;
1313 else
1314 log_error("Failed to process bus a: %s", strerror(-r));
1315
1316 goto finish;
1317 }
1318
1319 if (m) {
1320 /* We officially got EOF, let's quit */
1321 if (sd_bus_message_is_signal(m, "org.freedesktop.DBus.Local", "Disconnected")) {
1322 r = 0;
1323 goto finish;
1324 }
1325
1326 k = synthesize_name_acquired(a, b, m);
1327 if (k < 0) {
1328 r = k;
1329 log_error("Failed to synthesize message: %s", strerror(-r));
1330 goto finish;
1331 }
1332
1333 patch_sender(a, m);
1334
1335 k = sd_bus_send(b, m, NULL);
1336 if (k < 0) {
1337 if (k == -ECONNRESET)
1338 r = 0;
1339 else {
1340 r = k;
1341 log_error("Failed to send message: %s", strerror(-r));
1342 }
1343
1344 goto finish;
1345 }
1346 }
1347
1348 if (r > 0)
1349 continue;
1350 }
1351
1352 r = sd_bus_process(b, &m);
1353 if (r < 0) {
1354 /* treat 'connection reset by peer' as clean exit condition */
1355 if (r == -ECONNRESET)
1356 r = 0;
1357 else
1358 log_error("Failed to process bus b: %s", strerror(-r));
1359
1360 goto finish;
1361 }
1362
1363 if (m) {
1364 /* We officially got EOF, let's quit */
1365 if (sd_bus_message_is_signal(m, "org.freedesktop.DBus.Local", "Disconnected")) {
1366 r = 0;
1367 goto finish;
1368 }
1369
1370 k = process_hello(a, b, m, &got_hello);
1371 if (k < 0) {
1372 r = k;
1373 log_error("Failed to process HELLO: %s", strerror(-r));
1374 goto finish;
1375 }
1376
1377 if (k > 0)
1378 r = k;
1379 else {
1380 k = process_policy(a, b, m);
1381 if (k < 0) {
1382 r = k;
1383 log_error("Failed to process policy: %s", strerror(-r));
1384 goto finish;
1385 }
1386
1387 k = process_driver(a, b, m);
1388 if (k < 0) {
1389 r = k;
1390 log_error("Failed to process driver calls: %s", strerror(-r));
1391 goto finish;
1392 }
1393
1394 if (k > 0)
1395 r = k;
1396 else {
1397 k = sd_bus_send(a, m, NULL);
1398 if (k < 0) {
1399 if (k == -ECONNRESET)
1400 r = 0;
1401 else {
1402 r = k;
1403 log_error("Failed to send message: %s", strerror(-r));
1404 }
1405
1406 goto finish;
1407 }
1408 }
1409 }
1410 }
1411
1412 if (r > 0)
1413 continue;
1414
1415 fd = sd_bus_get_fd(a);
1416 if (fd < 0) {
1417 log_error("Failed to get fd: %s", strerror(-r));
1418 goto finish;
1419 }
1420
1421 events_a = sd_bus_get_events(a);
1422 if (events_a < 0) {
1423 log_error("Failed to get events mask: %s", strerror(-r));
1424 goto finish;
1425 }
1426
1427 r = sd_bus_get_timeout(a, &timeout_a);
1428 if (r < 0) {
1429 log_error("Failed to get timeout: %s", strerror(-r));
1430 goto finish;
1431 }
1432
1433 events_b = sd_bus_get_events(b);
1434 if (events_b < 0) {
1435 log_error("Failed to get events mask: %s", strerror(-r));
1436 goto finish;
1437 }
1438
1439 r = sd_bus_get_timeout(b, &timeout_b);
1440 if (r < 0) {
1441 log_error("Failed to get timeout: %s", strerror(-r));
1442 goto finish;
1443 }
1444
1445 t = timeout_a;
1446 if (t == (uint64_t) -1 || (timeout_b != (uint64_t) -1 && timeout_b < timeout_a))
1447 t = timeout_b;
1448
1449 if (t == (uint64_t) -1)
1450 ts = NULL;
1451 else {
1452 usec_t nw;
1453
1454 nw = now(CLOCK_MONOTONIC);
1455 if (t > nw)
1456 t -= nw;
1457 else
1458 t = 0;
1459
1460 ts = timespec_store(&_ts, t);
1461 }
1462
1463 pollfd = (struct pollfd[3]) {
1464 {.fd = fd, .events = events_a, },
1465 {.fd = in_fd, .events = events_b & POLLIN, },
1466 {.fd = out_fd, .events = events_b & POLLOUT, }
1467 };
1468
1469 r = ppoll(pollfd, 3, ts, NULL);
1470 if (r < 0) {
1471 log_error("ppoll() failed: %m");
1472 goto finish;
1473 }
1474 }
1475
1476 finish:
1477 policy_free(&policy);
1478 strv_free(arg_configuration);
1479 free(arg_address);
1480
1481 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1482 }
Unnamed repository; edit this file 'description' to name the repository.