]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/dbus.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
dbus: don't try to connect to the system bus before it is actually up
[thirdparty/systemd.git] / src / dbus.c
CommitLineData
d6c9574f 1/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
ea430986 2
a7334b09
LP		 3/***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20***/
21
ea430986
LP		 22#include <sys/epoll.h>
23#include <sys/timerfd.h>
24#include <errno.h>
25#include <unistd.h>
4139c1b2 26#include <dbus/dbus.h>
ea430986
LP		 27
28#include "dbus.h"
29#include "log.h"
30#include "strv.h"
8e274523 31#include "cgroup.h"
4139c1b2
LP		 32#include "dbus-unit.h"
33#include "dbus-job.h"
34#include "dbus-manager.h"
4288f619
LP		 35#include "dbus-service.h"
36#include "dbus-socket.h"
37#include "dbus-target.h"
38#include "dbus-device.h"
39#include "dbus-mount.h"
40#include "dbus-automount.h"
41#include "dbus-snapshot.h"
42#include "dbus-swap.h"
871d7de4 43#include "dbus-timer.h"
01f78473 44#include "dbus-path.h"
398ef8ba 45#include "bus-errors.h"
8f6df3fa 46#include "special.h"
4288f619 47
5e8d1c9a
LP		 48#define CONNECTIONS_MAX 52
49
4288f619
LP		 50static const char bus_properties_interface[] = BUS_PROPERTIES_INTERFACE;
51static const char bus_introspectable_interface[] = BUS_INTROSPECTABLE_INTERFACE;
52
53const char *const bus_interface_table[] = {
54 "org.freedesktop.DBus.Properties", bus_properties_interface,
55 "org.freedesktop.DBus.Introspectable", bus_introspectable_interface,
56 "org.freedesktop.systemd1.Manager", bus_manager_interface,
57 "org.freedesktop.systemd1.Job", bus_job_interface,
58 "org.freedesktop.systemd1.Unit", bus_unit_interface,
59 "org.freedesktop.systemd1.Service", bus_service_interface,
60 "org.freedesktop.systemd1.Socket", bus_socket_interface,
61 "org.freedesktop.systemd1.Target", bus_target_interface,
62 "org.freedesktop.systemd1.Device", bus_device_interface,
63 "org.freedesktop.systemd1.Mount", bus_mount_interface,
64 "org.freedesktop.systemd1.Automount", bus_automount_interface,
65 "org.freedesktop.systemd1.Snapshot", bus_snapshot_interface,
66 "org.freedesktop.systemd1.Swap", bus_swap_interface,
871d7de4 67 "org.freedesktop.systemd1.Timer", bus_timer_interface,
01f78473 68 "org.freedesktop.systemd1.Path", bus_path_interface,
4288f619
LP		 69 NULL
70};
ea430986 71
0034c15c 72static const char *error_to_dbus(int error);
5e8d1c9a
LP		 73static void bus_done_api(Manager *m);
74static void bus_done_system(Manager *m);
75static void bus_done_private(Manager *m);
923f8d76 76static void shutdown_connection(Manager *m, DBusConnection *c);
0034c15c 77
5e8d1c9a 78static void bus_dispatch_status(DBusConnection *bus, DBusDispatchStatus status, void *data) {
8e274523
LP		 79 Manager *m = data;
80
81 assert(bus);
82 assert(m);
2e317f52 83
5e8d1c9a
LP		 84 /* We maintain two sets, one for those connections where we
85 * requested a dispatch, and another where we didn't. And then,
86 * we move the connections between the two sets. */
8e274523 87
5e8d1c9a
LP		 88 if (status == DBUS_DISPATCH_COMPLETE)
89 set_move_one(m->bus_connections, m->bus_connections_for_dispatch, bus);
90 else
91 set_move_one(m->bus_connections_for_dispatch, m->bus_connections, bus);
8e274523
LP		 92}
93
ea430986
LP		 94static uint32_t bus_flags_to_events(DBusWatch *bus_watch) {
95 unsigned flags;
96 uint32_t events = 0;
97
98 assert(bus_watch);
99
100 /* no watch flags for disabled watches */
101 if (!dbus_watch_get_enabled(bus_watch))
102 return 0;
103
104 flags = dbus_watch_get_flags(bus_watch);
105
106 if (flags & DBUS_WATCH_READABLE)
107 events |= EPOLLIN;
108 if (flags & DBUS_WATCH_WRITABLE)
109 events |= EPOLLOUT;
110
111 return events | EPOLLHUP | EPOLLERR;
112}
113
114static unsigned events_to_bus_flags(uint32_t events) {
115 unsigned flags = 0;
116
117 if (events & EPOLLIN)
118 flags |= DBUS_WATCH_READABLE;
119 if (events & EPOLLOUT)
120 flags |= DBUS_WATCH_WRITABLE;
121 if (events & EPOLLHUP)
122 flags |= DBUS_WATCH_HANGUP;
123 if (events & EPOLLERR)
124 flags |= DBUS_WATCH_ERROR;
125
126 return flags;
127}
128
129void bus_watch_event(Manager *m, Watch *w, int events) {
130 assert(m);
131 assert(w);
132
133 /* This is called by the event loop whenever there is
134 * something happening on D-Bus' file handles. */
135
8e274523 136 if (!dbus_watch_get_enabled(w->data.bus_watch))
ea430986
LP		 137 return;
138
139 dbus_watch_handle(w->data.bus_watch, events_to_bus_flags(events));
140}
141
142static dbus_bool_t bus_add_watch(DBusWatch *bus_watch, void *data) {
143 Manager *m = data;
144 Watch *w;
145 struct epoll_event ev;
146
147 assert(bus_watch);
148 assert(m);
149
150 if (!(w = new0(Watch, 1)))
151 return FALSE;
152
153 w->fd = dbus_watch_get_unix_fd(bus_watch);
154 w->type = WATCH_DBUS_WATCH;
155 w->data.bus_watch = bus_watch;
156
157 zero(ev);
158 ev.events = bus_flags_to_events(bus_watch);
159 ev.data.ptr = w;
160
161 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, w->fd, &ev) < 0) {
162
163 if (errno != EEXIST) {
164 free(w);
165 return FALSE;
166 }
167
168 /* Hmm, bloody D-Bus creates multiple watches on the
169 * same fd. epoll() does not like that. As a dirty
170 * hack we simply dup() the fd and hence get a second
171 * one we can safely add to the epoll(). */
172
173 if ((w->fd = dup(w->fd)) < 0) {
174 free(w);
175 return FALSE;
176 }
177
178 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, w->fd, &ev) < 0) {
179 free(w);
180 close_nointr_nofail(w->fd);
181 return FALSE;
182 }
183
184 w->fd_is_dupped = true;
185 }
186
187 dbus_watch_set_data(bus_watch, w, NULL);
188
189 return TRUE;
190}
191
192static void bus_remove_watch(DBusWatch *bus_watch, void *data) {
193 Manager *m = data;
194 Watch *w;
195
196 assert(bus_watch);
197 assert(m);
198
199 if (!(w = dbus_watch_get_data(bus_watch)))
200 return;
201
202 assert(w->type == WATCH_DBUS_WATCH);
203 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
204
205 if (w->fd_is_dupped)
206 close_nointr_nofail(w->fd);
207
208 free(w);
209}
210
211static void bus_toggle_watch(DBusWatch *bus_watch, void *data) {
212 Manager *m = data;
213 Watch *w;
214 struct epoll_event ev;
215
216 assert(bus_watch);
217 assert(m);
218
219 assert_se(w = dbus_watch_get_data(bus_watch));
220 assert(w->type == WATCH_DBUS_WATCH);
221
222 zero(ev);
223 ev.events = bus_flags_to_events(bus_watch);
224 ev.data.ptr = w;
225
226 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_MOD, w->fd, &ev) == 0);
227}
228
229static int bus_timeout_arm(Manager *m, Watch *w) {
230 struct itimerspec its;
231
232 assert(m);
233 assert(w);
234
235 zero(its);
236
237 if (dbus_timeout_get_enabled(w->data.bus_timeout)) {
238 timespec_store(&its.it_value, dbus_timeout_get_interval(w->data.bus_timeout) * USEC_PER_MSEC);
239 its.it_interval = its.it_interval;
240 }
241
242 if (timerfd_settime(w->fd, 0, &its, NULL) < 0)
243 return -errno;
244
245 return 0;
246}
247
248void bus_timeout_event(Manager *m, Watch *w, int events) {
249 assert(m);
250 assert(w);
251
252 /* This is called by the event loop whenever there is
253 * something happening on D-Bus' file handles. */
254
255 if (!(dbus_timeout_get_enabled(w->data.bus_timeout)))
256 return;
257
258 dbus_timeout_handle(w->data.bus_timeout);
259}
260
261static dbus_bool_t bus_add_timeout(DBusTimeout *timeout, void *data) {
262 Manager *m = data;
263 Watch *w;
264 struct epoll_event ev;
265
266 assert(timeout);
267 assert(m);
268
269 if (!(w = new0(Watch, 1)))
270 return FALSE;
271
272 if (!(w->fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC)) < 0)
273 goto fail;
274
275 w->type = WATCH_DBUS_TIMEOUT;
276 w->data.bus_timeout = timeout;
277
278 if (bus_timeout_arm(m, w) < 0)
279 goto fail;
280
281 zero(ev);
282 ev.events = EPOLLIN;
283 ev.data.ptr = w;
284
285 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, w->fd, &ev) < 0)
286 goto fail;
287
288 dbus_timeout_set_data(timeout, w, NULL);
289
290 return TRUE;
291
292fail:
293 if (w->fd >= 0)
294 close_nointr_nofail(w->fd);
295
296 free(w);
297 return FALSE;
298}
299
300static void bus_remove_timeout(DBusTimeout *timeout, void *data) {
301 Manager *m = data;
302 Watch *w;
303
304 assert(timeout);
305 assert(m);
306
307 if (!(w = dbus_timeout_get_data(timeout)))
308 return;
309
310 assert(w->type == WATCH_DBUS_TIMEOUT);
311 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
312 close_nointr_nofail(w->fd);
313 free(w);
314}
315
316static void bus_toggle_timeout(DBusTimeout *timeout, void *data) {
317 Manager *m = data;
318 Watch *w;
319 int r;
320
321 assert(timeout);
322 assert(m);
323
324 assert_se(w = dbus_timeout_get_data(timeout));
325 assert(w->type == WATCH_DBUS_TIMEOUT);
326
327 if ((r = bus_timeout_arm(m, w)) < 0)
328 log_error("Failed to rearm timer: %s", strerror(-r));
329}
330
cf3e2471 331static DBusHandlerResult api_bus_message_filter(DBusConnection *connection, DBusMessage *message, void *data) {
c1e1601e
LP		 332 Manager *m = data;
333 DBusError error;
0034c15c 334 DBusMessage *reply = NULL;
c1e1601e
LP		 335
336 assert(connection);
337 assert(message);
338 assert(m);
339
340 dbus_error_init(&error);
341
1e001f52
LP		 342 if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_METHOD_CALL ||
343 dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_SIGNAL)
344 log_debug("Got D-Bus request: %s.%s() on %s",
345 dbus_message_get_interface(message),
346 dbus_message_get_member(message),
347 dbus_message_get_path(message));
c1e1601e
LP		 348
349 if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) {
9028d0ec 350 log_debug("API D-Bus connection terminated.");
f278026d 351 bus_done_api(m);
c1e1601e
LP		 352
353 } else if (dbus_message_is_signal(message, DBUS_INTERFACE_DBUS, "NameOwnerChanged")) {
05e343b7 354 const char *name, *old_owner, *new_owner;
c1e1601e
LP		 355
356 if (!dbus_message_get_args(message, &error,
357 DBUS_TYPE_STRING, &name,
05e343b7
LP		 358 DBUS_TYPE_STRING, &old_owner,
359 DBUS_TYPE_STRING, &new_owner,
c1e1601e
LP		 360 DBUS_TYPE_INVALID))
361 log_error("Failed to parse NameOwnerChanged message: %s", error.message);
362 else {
a567261a
LP		 363 if (set_remove(BUS_CONNECTION_SUBSCRIBED(m, connection), (char*) name))
364 log_debug("Subscription client vanished: %s (left: %u)", name, set_size(BUS_CONNECTION_SUBSCRIBED(m, connection)));
05e343b7
LP		 365
366 if (old_owner[0] == 0)
367 old_owner = NULL;
368
369 if (new_owner[0] == 0)
370 new_owner = NULL;
371
372 manager_dispatch_bus_name_owner_changed(m, name, old_owner, new_owner);
c1e1601e 373 }
0034c15c
LP		 374 } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Activator", "ActivationRequest")) {
375 const char *name;
376
377 if (!dbus_message_get_args(message, &error,
378 DBUS_TYPE_STRING, &name,
379 DBUS_TYPE_INVALID))
380 log_error("Failed to parse ActivationRequest message: %s", error.message);
381 else {
382 int r;
383 Unit *u;
384
46018844
LP		 385 log_debug("Got D-Bus activation request for %s", name);
386
8f6df3fa
LP		 387 if (manager_unit_pending_inactive(m, SPECIAL_DBUS_SERVICE) ||
388 manager_unit_pending_inactive(m, SPECIAL_DBUS_SOCKET)) {
389 r = -EADDRNOTAVAIL;
390 dbus_set_error(&error, BUS_ERROR_SHUTTING_DOWN, "Refusing activation, D-Bus is shutting down.");
391 } else {
392 r = manager_load_unit(m, name, NULL, &error, &u);
0034c15c 393
8f6df3fa
LP		 394 if (r >= 0 && u->meta.refuse_manual_start)
395 r = -EPERM;
0034c15c 396
8f6df3fa
LP		 397 if (r >= 0)
398 r = manager_add_job(m, JOB_START, u, JOB_REPLACE, true, &error, NULL);
399 }
0034c15c
LP		 400
401 if (r < 0) {
402 const char *id, *text;
403
2a8cd298 404 log_debug("D-Bus activation failed for %s: %s", name, strerror(-r));
af25ec12 405
0034c15c
LP		 406 if (!(reply = dbus_message_new_signal("/org/freedesktop/systemd1", "org.freedesktop.systemd1.Activator", "ActivationFailure")))
407 goto oom;
408
398ef8ba
LP		 409 id = error.name ? error.name : error_to_dbus(r);
410 text = bus_error(&error, r);
0034c15c
LP		 411
412 if (!dbus_message_set_destination(reply, DBUS_SERVICE_DBUS) ||
413 !dbus_message_append_args(reply,
414 DBUS_TYPE_STRING, &name,
415 DBUS_TYPE_STRING, &id,
416 DBUS_TYPE_STRING, &text,
417 DBUS_TYPE_INVALID))
418 goto oom;
419 }
420
421 /* On success we don't do anything, the service will be spwaned now */
422 }
c1e1601e
LP		 423 }
424
425 dbus_error_free(&error);
0034c15c
LP		 426
427 if (reply) {
428 if (!dbus_connection_send(connection, reply, NULL))
429 goto oom;
430
431 dbus_message_unref(reply);
432 }
433
c1e1601e 434 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
0034c15c
LP		 435
436oom:
437 if (reply)
438 dbus_message_unref(reply);
439
440 dbus_error_free(&error);
441
442 return DBUS_HANDLER_RESULT_NEED_MEMORY;
c1e1601e
LP		 443}
444
cf3e2471 445static DBusHandlerResult system_bus_message_filter(DBusConnection *connection, DBusMessage *message, void *data) {
8e274523
LP		 446 Manager *m = data;
447 DBusError error;
448
449 assert(connection);
450 assert(message);
451 assert(m);
452
453 dbus_error_init(&error);
454
1e001f52
LP		 455 if (m->api_bus != m->system_bus &&
456 (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_METHOD_CALL ||
457 dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_SIGNAL))
458 log_debug("Got D-Bus request on system bus: %s.%s() on %s",
459 dbus_message_get_interface(message),
460 dbus_message_get_member(message),
461 dbus_message_get_path(message));
8e274523
LP		 462
463 if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) {
91805b3b 464 log_debug("System D-Bus connection terminated.");
f278026d 465 bus_done_system(m);
8e274523 466
53c6a358
LP		 467 } else if (m->running_as != MANAGER_SYSTEM &&
468 dbus_message_is_signal(message, "org.freedesktop.systemd1.Agent", "Released")) {
469
8e274523
LP		 470 const char *cgroup;
471
472 if (!dbus_message_get_args(message, &error,
473 DBUS_TYPE_STRING, &cgroup,
474 DBUS_TYPE_INVALID))
475 log_error("Failed to parse Released message: %s", error.message);
476 else
477 cgroup_notify_empty(m, cgroup);
478 }
479
480 dbus_error_free(&error);
481 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
482}
483
5e8d1c9a
LP		 484static DBusHandlerResult private_bus_message_filter(DBusConnection *connection, DBusMessage *message, void *data) {
485 Manager *m = data;
3c661fad 486 DBusError error;
5e8d1c9a
LP		 487
488 assert(connection);
489 assert(message);
490 assert(m);
491
3c661fad
LP		 492 dbus_error_init(&error);
493
1e001f52
LP		 494 if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_METHOD_CALL ||
495 dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_SIGNAL)
496 log_debug("Got D-Bus request: %s.%s() on %s",
497 dbus_message_get_interface(message),
498 dbus_message_get_member(message),
499 dbus_message_get_path(message));
5e8d1c9a 500
923f8d76
LP		 501 if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected"))
502 shutdown_connection(m, connection);
53c6a358
LP		 503 else if (m->running_as == MANAGER_SYSTEM &&
504 dbus_message_is_signal(message, "org.freedesktop.systemd1.Agent", "Released")) {
505
3c661fad
LP		 506 const char *cgroup;
507
508 if (!dbus_message_get_args(message, &error,
509 DBUS_TYPE_STRING, &cgroup,
510 DBUS_TYPE_INVALID))
511 log_error("Failed to parse Released message: %s", error.message);
512 else
513 cgroup_notify_empty(m, cgroup);
53c6a358
LP		 514
515 /* Forward the message to the system bus, so that user
516 * instances are notified as well */
517
518 if (m->system_bus)
519 dbus_connection_send(m->system_bus, message, NULL);
3c661fad
LP		 520 }
521
522 dbus_error_free(&error);
5e8d1c9a
LP		 523
524 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
525}
526
c1e1601e 527unsigned bus_dispatch(Manager *m) {
5e8d1c9a
LP		 528 DBusConnection *c;
529
ea430986
LP		 530 assert(m);
531
a16e1123
LP		 532 if (m->queued_message) {
533 /* If we cannot get rid of this message we won't
534 * dispatch any D-Bus messages, so that we won't end
535 * up wanting to queue another message. */
536
7b97f477
LP		 537 if (m->queued_message_connection)
538 if (!dbus_connection_send(m->queued_message_connection, m->queued_message, NULL))
5e8d1c9a 539 return 0;
a16e1123
LP		 540
541 dbus_message_unref(m->queued_message);
542 m->queued_message = NULL;
7b97f477 543 m->queued_message_connection = NULL;
a16e1123
LP		 544 }
545
5e8d1c9a
LP		 546 if ((c = set_first(m->bus_connections_for_dispatch))) {
547 if (dbus_connection_dispatch(c) == DBUS_DISPATCH_COMPLETE)
548 set_move_one(m->bus_connections, m->bus_connections_for_dispatch, c);
fd18e1f4
LP		 549
550 return 1;
551 }
c1e1601e 552
8e274523 553 return 0;
ea430986
LP		 554}
555
05e343b7 556static void request_name_pending_cb(DBusPendingCall *pending, void *userdata) {
61902ea3
LP		 557 DBusMessage *reply;
558 DBusError error;
559
560 dbus_error_init(&error);
561
562 assert_se(reply = dbus_pending_call_steal_reply(pending));
563
564 switch (dbus_message_get_type(reply)) {
565
566 case DBUS_MESSAGE_TYPE_ERROR:
567
568 assert_se(dbus_set_error_from_message(&error, reply));
569 log_warning("RequestName() failed: %s", error.message);
570 break;
571
572 case DBUS_MESSAGE_TYPE_METHOD_RETURN: {
573 uint32_t r;
574
575 if (!dbus_message_get_args(reply,
576 &error,
577 DBUS_TYPE_UINT32, &r,
578 DBUS_TYPE_INVALID)) {
579 log_error("Failed to parse RequestName() reply: %s", error.message);
580 break;
581 }
582
583 if (r == 1)
584 log_debug("Successfully acquired name.");
585 else
586 log_error("Name already owned.");
587
588 break;
589 }
590
591 default:
592 assert_not_reached("Invalid reply message");
593 }
594
595 dbus_message_unref(reply);
596 dbus_error_free(&error);
597}
598
ea430986 599static int request_name(Manager *m) {
ea430986
LP		 600 const char *name = "org.freedesktop.systemd1";
601 uint32_t flags = 0;
05e343b7
LP		 602 DBusMessage *message = NULL;
603 DBusPendingCall *pending = NULL;
ea430986
LP		 604
605 if (!(message = dbus_message_new_method_call(
606 DBUS_SERVICE_DBUS,
607 DBUS_PATH_DBUS,
608 DBUS_INTERFACE_DBUS,
609 "RequestName")))
05e343b7 610 goto oom;
ea430986
LP		 611
612 if (!dbus_message_append_args(
613 message,
614 DBUS_TYPE_STRING, &name,
615 DBUS_TYPE_UINT32, &flags,
05e343b7
LP		 616 DBUS_TYPE_INVALID))
617 goto oom;
ea430986 618
05e343b7
LP		 619 if (!dbus_connection_send_with_reply(m->api_bus, message, &pending, -1))
620 goto oom;
ea430986 621
05e343b7
LP		 622 if (!dbus_pending_call_set_notify(pending, request_name_pending_cb, m, NULL))
623 goto oom;
ea430986
LP		 624
625 dbus_message_unref(message);
61902ea3
LP		 626 dbus_pending_call_unref(pending);
627
628 /* We simple ask for the name and don't wait for it. Sooner or
629 * later we'll have it. */
630
ea430986 631 return 0;
05e343b7
LP		 632
633oom:
634 if (pending) {
635 dbus_pending_call_cancel(pending);
636 dbus_pending_call_unref(pending);
637 }
638
639 if (message)
640 dbus_message_unref(message);
641
642 return -ENOMEM;
ea430986
LP		 643}
644
6dded4c7
LP		 645static void query_name_list_pending_cb(DBusPendingCall *pending, void *userdata) {
646 DBusMessage *reply;
647 DBusError error;
648 Manager *m = userdata;
649
650 assert(m);
651
652 dbus_error_init(&error);
653
654 assert_se(reply = dbus_pending_call_steal_reply(pending));
655
656 switch (dbus_message_get_type(reply)) {
657
658 case DBUS_MESSAGE_TYPE_ERROR:
659
660 assert_se(dbus_set_error_from_message(&error, reply));
661 log_warning("ListNames() failed: %s", error.message);
662 break;
663
664 case DBUS_MESSAGE_TYPE_METHOD_RETURN: {
665 int r;
666 char **l;
667
668 if ((r = bus_parse_strv(reply, &l)) < 0)
669 log_warning("Failed to parse ListNames() reply: %s", strerror(-r));
670 else {
671 char **t;
672
673 STRV_FOREACH(t, l)
674 /* This is a bit hacky, we say the
675 * owner of the name is the name
676 * itself, because we don't want the
677 * extra traffic to figure out the
678 * real owner. */
679 manager_dispatch_bus_name_owner_changed(m, *t, NULL, *t);
680
681 strv_free(l);
682 }
683
684 break;
685 }
686
687 default:
688 assert_not_reached("Invalid reply message");
689 }
690
691 dbus_message_unref(reply);
692 dbus_error_free(&error);
693}
694
695static int query_name_list(Manager *m) {
696 DBusMessage *message = NULL;
697 DBusPendingCall *pending = NULL;
698
699 /* Asks for the currently installed bus names */
700
701 if (!(message = dbus_message_new_method_call(
702 DBUS_SERVICE_DBUS,
703 DBUS_PATH_DBUS,
704 DBUS_INTERFACE_DBUS,
705 "ListNames")))
706 goto oom;
707
708 if (!dbus_connection_send_with_reply(m->api_bus, message, &pending, -1))
709 goto oom;
710
711 if (!dbus_pending_call_set_notify(pending, query_name_list_pending_cb, m, NULL))
712 goto oom;
713
714 dbus_message_unref(message);
715 dbus_pending_call_unref(pending);
716
717 /* We simple ask for the list and don't wait for it. Sooner or
718 * later we'll get it. */
719
720 return 0;
721
722oom:
723 if (pending) {
724 dbus_pending_call_cancel(pending);
725 dbus_pending_call_unref(pending);
726 }
727
728 if (message)
729 dbus_message_unref(message);
730
731 return -ENOMEM;
732}
733
8e274523
LP		 734static int bus_setup_loop(Manager *m, DBusConnection *bus) {
735 assert(m);
736 assert(bus);
737
738 dbus_connection_set_exit_on_disconnect(bus, FALSE);
fd18e1f4 739
8e274523 740 if (!dbus_connection_set_watch_functions(bus, bus_add_watch, bus_remove_watch, bus_toggle_watch, m, NULL) ||
5e8d1c9a
LP		 741 !dbus_connection_set_timeout_functions(bus, bus_add_timeout, bus_remove_timeout, bus_toggle_timeout, m, NULL)) {
742 log_error("Not enough memory");
8e274523 743 return -ENOMEM;
5e8d1c9a 744 }
8e274523 745
5e8d1c9a
LP		 746 if (set_put(m->bus_connections_for_dispatch, bus) < 0) {
747 log_error("Not enough memory");
748 return -ENOMEM;
749 }
750
751 dbus_connection_set_dispatch_status_function(bus, bus_dispatch_status, m, NULL);
8e274523
LP		 752 return 0;
753}
754
5e8d1c9a
LP		 755static dbus_bool_t allow_only_root(DBusConnection *connection, unsigned long uid, void *data) {
756 return uid == 0;
757}
758
759static void bus_new_connection(
760 DBusServer *server,
761 DBusConnection *new_connection,
762 void *data) {
763
764 Manager *m = data;
765
766 assert(m);
767
768 if (set_size(m->bus_connections) >= CONNECTIONS_MAX) {
769 log_error("Too many concurrent connections.");
770 return;
771 }
772
773 dbus_connection_set_unix_user_function(new_connection, allow_only_root, NULL, NULL);
774
775 if (bus_setup_loop(m, new_connection) < 0)
776 return;
777
778 if (!dbus_connection_register_object_path(new_connection, "/org/freedesktop/systemd1", &bus_manager_vtable, m) ||
779 !dbus_connection_register_fallback(new_connection, "/org/freedesktop/systemd1/unit", &bus_unit_vtable, m) ||
780 !dbus_connection_register_fallback(new_connection, "/org/freedesktop/systemd1/job", &bus_job_vtable, m) ||
781 !dbus_connection_add_filter(new_connection, private_bus_message_filter, m, NULL)) {
782 log_error("Not enough memory.");
783 return;
784 }
785
786 log_debug("Accepted connection on private bus.");
787
788 dbus_connection_ref(new_connection);
789}
790
791static int bus_init_system(Manager *m) {
ea430986 792 DBusError error;
ea430986
LP		 793 int r;
794
795 assert(m);
796
ea430986 797 dbus_error_init(&error);
ea430986 798
f278026d
LP		 799 if (m->system_bus)
800 return 0;
8e274523 801
a3d4e06d 802 if (m->running_as == MANAGER_SYSTEM && m->api_bus)
f278026d
LP		 803 m->system_bus = m->api_bus;
804 else {
8e274523 805 if (!(m->system_bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error))) {
266e525c 806 log_debug("Failed to get system D-Bus connection, retrying later: %s", error.message);
5e8d1c9a
LP		 807 r = 0;
808 goto fail;
8e274523
LP		 809 }
810
5e8d1c9a
LP		 811 if ((r = bus_setup_loop(m, m->system_bus)) < 0)
812 goto fail;
f278026d
LP		 813 }
814
815 if (!dbus_connection_add_filter(m->system_bus, system_bus_message_filter, m, NULL)) {
5e8d1c9a
LP		 816 log_error("Not enough memory");
817 r = -EIO;
818 goto fail;
c1e1601e
LP		 819 }
820
53c6a358
LP		 821 if (m->running_as != MANAGER_SYSTEM) {
822 dbus_bus_add_match(m->system_bus,
823 "type='signal',"
824 "interface='org.freedesktop.systemd1.Agent',"
825 "member='Released',"
826 "path='/org/freedesktop/systemd1/agent'",
827 &error);
828
829 if (dbus_error_is_set(&error)) {
830 log_error("Failed to register match: %s", error.message);
831 r = -EIO;
832 goto fail;
833 }
ea430986
LP		 834 }
835
9014a8bd
LP		 836 if (m->api_bus != m->system_bus) {
837 char *id;
91805b3b 838 log_debug("Successfully connected to system D-Bus bus %s as %s",
9014a8bd
LP		 839 strnull((id = dbus_connection_get_server_id(m->system_bus))),
840 strnull(dbus_bus_get_unique_name(m->system_bus)));
841 dbus_free(id);
842 }
f278026d 843
f278026d 844 return 0;
5e8d1c9a
LP		 845
846fail:
847 bus_done_system(m);
848 dbus_error_free(&error);
849
850 return r;
f278026d
LP		 851}
852
5e8d1c9a 853static int bus_init_api(Manager *m) {
f278026d 854 DBusError error;
f278026d
LP		 855 int r;
856
857 assert(m);
858
859 dbus_error_init(&error);
860
861 if (m->api_bus)
862 return 0;
863
a3d4e06d 864 if (m->running_as == MANAGER_SYSTEM && m->system_bus)
f278026d
LP		 865 m->api_bus = m->system_bus;
866 else {
af2d49f7 867 if (!(m->api_bus = dbus_bus_get_private(m->running_as == MANAGER_USER ? DBUS_BUS_SESSION : DBUS_BUS_SYSTEM, &error))) {
266e525c 868 log_debug("Failed to get API D-Bus connection, retrying later: %s", error.message);
5e8d1c9a
LP		 869 r = 0;
870 goto fail;
f278026d
LP		 871 }
872
5e8d1c9a
LP		 873 if ((r = bus_setup_loop(m, m->api_bus)) < 0)
874 goto fail;
ea430986
LP		 875 }
876
f278026d
LP		 877 if (!dbus_connection_register_object_path(m->api_bus, "/org/freedesktop/systemd1", &bus_manager_vtable, m) ||
878 !dbus_connection_register_fallback(m->api_bus, "/org/freedesktop/systemd1/unit", &bus_unit_vtable, m) ||
879 !dbus_connection_register_fallback(m->api_bus, "/org/freedesktop/systemd1/job", &bus_job_vtable, m) ||
880 !dbus_connection_add_filter(m->api_bus, api_bus_message_filter, m, NULL)) {
5e8d1c9a
LP		 881 log_error("Not enough memory");
882 r = -ENOMEM;
883 goto fail;
f278026d
LP		 884 }
885
0034c15c 886 /* Get NameOwnerChange messages */
f278026d 887 dbus_bus_add_match(m->api_bus,
8e274523 888 "type='signal',"
f278026d
LP		 889 "sender='"DBUS_SERVICE_DBUS"',"
890 "interface='"DBUS_INTERFACE_DBUS"',"
fd0d7f7a 891 "member='NameOwnerChanged',"
f278026d 892 "path='"DBUS_PATH_DBUS"'",
8e274523
LP		 893 &error);
894
895 if (dbus_error_is_set(&error)) {
896 log_error("Failed to register match: %s", error.message);
5e8d1c9a
LP		 897 r = -EIO;
898 goto fail;
8e274523
LP		 899 }
900
0034c15c
LP		 901 /* Get activation requests */
902 dbus_bus_add_match(m->api_bus,
903 "type='signal',"
904 "sender='"DBUS_SERVICE_DBUS"',"
905 "interface='org.freedesktop.systemd1.Activator',"
cf3e2471 906 "member='ActivationRequest',"
0034c15c
LP		 907 "path='"DBUS_PATH_DBUS"'",
908 &error);
909
910 if (dbus_error_is_set(&error)) {
911 log_error("Failed to register match: %s", error.message);
5e8d1c9a
LP		 912 r = -EIO;
913 goto fail;
0034c15c
LP		 914 }
915
5e8d1c9a
LP		 916 if ((r = request_name(m)) < 0)
917 goto fail;
ea430986 918
5e8d1c9a
LP		 919 if ((r = query_name_list(m)) < 0)
920 goto fail;
6dded4c7 921
9014a8bd
LP		 922 if (m->api_bus != m->system_bus) {
923 char *id;
91805b3b 924 log_debug("Successfully connected to API D-Bus bus %s as %s",
9014a8bd
LP		 925 strnull((id = dbus_connection_get_server_id(m->api_bus))),
926 strnull(dbus_bus_get_unique_name(m->api_bus)));
927 dbus_free(id);
928 }
8e274523 929
5e8d1c9a
LP		 930 return 0;
931
932fail:
933 bus_done_api(m);
934 dbus_error_free(&error);
935
936 return r;
937}
938
939static int bus_init_private(Manager *m) {
940 DBusError error;
941 int r;
942 const char *const external_only[] = {
943 "EXTERNAL",
944 NULL
945 };
946
947 assert(m);
948
949 dbus_error_init(&error);
950
951 if (m->private_bus)
952 return 0;
953
954 /* We want the private bus only when running as init */
a821caaa 955 if (getpid() != 1)
5e8d1c9a
LP		 956 return 0;
957
958 if (!(m->private_bus = dbus_server_listen("unix:abstract=/org/freedesktop/systemd1/private", &error))) {
959 log_error("Failed to create private D-Bus server: %s", error.message);
960 r = -EIO;
961 goto fail;
962 }
963
964 if (!dbus_server_set_auth_mechanisms(m->private_bus, (const char**) external_only) ||
965 !dbus_server_set_watch_functions(m->private_bus, bus_add_watch, bus_remove_watch, bus_toggle_watch, m, NULL) ||
966 !dbus_server_set_timeout_functions(m->private_bus, bus_add_timeout, bus_remove_timeout, bus_toggle_timeout, m, NULL)) {
967 log_error("Not enough memory");
968 r = -ENOMEM;
969 goto fail;
970 }
971
972 dbus_server_set_new_connection_function(m->private_bus, bus_new_connection, m, NULL);
973
54165a39 974 log_debug("Successfully created private D-Bus server.");
5e8d1c9a
LP		 975
976 return 0;
977
978fail:
979 bus_done_private(m);
980 dbus_error_free(&error);
981
982 return r;
983}
984
3996fbe2 985int bus_init(Manager *m, bool try_bus_connect) {
5e8d1c9a
LP		 986 int r;
987
988 if (set_ensure_allocated(&m->bus_connections, trivial_hash_func, trivial_compare_func) < 0 ||
989 set_ensure_allocated(&m->bus_connections_for_dispatch, trivial_hash_func, trivial_compare_func) < 0) {
990 log_error("Not enough memory");
991 return -ENOMEM;
992 }
993
994 if (m->name_data_slot < 0)
995 if (!dbus_pending_call_allocate_data_slot(&m->name_data_slot)) {
996 log_error("Not enough memory");
f278026d 997 return -ENOMEM;
5e8d1c9a
LP		 998 }
999
a567261a 1000 if (m->subscribed_data_slot < 0)
d83685ac 1001 if (!dbus_connection_allocate_data_slot(&m->subscribed_data_slot)) {
a567261a
LP		 1002 log_error("Not enough memory");
1003 return -ENOMEM;
1004 }
1005
3996fbe2
LP		 1006 if (try_bus_connect) {
1007 if ((r = bus_init_system(m)) < 0 ||
1008 (r = bus_init_api(m)) < 0)
1009 return r;
1010 }
1011
1012 if ((r = bus_init_private(m)) < 0)
5e8d1c9a 1013 return r;
f278026d 1014
ea430986
LP		 1015 return 0;
1016}
1017
fae20b11 1018static void shutdown_connection(Manager *m, DBusConnection *c) {
a567261a
LP		 1019 Set *s;
1020 Job *j;
1021 Iterator i;
1022
1023 HASHMAP_FOREACH(j, m->jobs, i)
1024 if (j->bus == c) {
1025 free(j->bus_client);
1026 j->bus_client = NULL;
1027
1028 j->bus = NULL;
1029 }
1030
fae20b11
LP		 1031 set_remove(m->bus_connections, c);
1032 set_remove(m->bus_connections_for_dispatch, c);
1033
a567261a
LP		 1034 if ((s = BUS_CONNECTION_SUBSCRIBED(m, c))) {
1035 char *t;
1036
1037 while ((t = set_steal_first(s)))
1038 free(t);
1039
1040 set_free(s);
1041 }
1042
7b97f477
LP		 1043 if (m->queued_message_connection == c) {
1044 m->queued_message_connection = NULL;
1045
1046 if (m->queued_message) {
1047 dbus_message_unref(m->queued_message);
1048 m->queued_message = NULL;
1049 }
1050 }
1051
5e8d1c9a
LP		 1052 dbus_connection_set_dispatch_status_function(c, NULL, NULL, NULL);
1053 dbus_connection_flush(c);
1054 dbus_connection_close(c);
1055 dbus_connection_unref(c);
1056}
1057
1058static void bus_done_api(Manager *m) {
ea430986
LP		 1059 assert(m);
1060
f278026d
LP		 1061 if (m->api_bus) {
1062 if (m->system_bus == m->api_bus)
1063 m->system_bus = NULL;
1064
fae20b11 1065 shutdown_connection(m, m->api_bus);
f278026d 1066 m->api_bus = NULL;
ea430986 1067 }
c1e1601e 1068
05e343b7 1069
a16e1123
LP		 1070 if (m->queued_message) {
1071 dbus_message_unref(m->queued_message);
1072 m->queued_message = NULL;
1073 }
ea430986
LP		 1074}
1075
5e8d1c9a 1076static void bus_done_system(Manager *m) {
f278026d
LP		 1077 assert(m);
1078
1079 if (m->system_bus == m->api_bus)
1080 bus_done_api(m);
1081
1082 if (m->system_bus) {
fae20b11 1083 shutdown_connection(m, m->system_bus);
f278026d
LP		 1084 m->system_bus = NULL;
1085 }
1086}
1087
5e8d1c9a
LP		 1088static void bus_done_private(Manager *m) {
1089
1090 if (m->private_bus) {
1091 dbus_server_disconnect(m->private_bus);
1092 dbus_server_unref(m->private_bus);
1093 m->private_bus = NULL;
1094 }
1095}
1096
1097void bus_done(Manager *m) {
1098 DBusConnection *c;
1099
1100 bus_done_api(m);
1101 bus_done_system(m);
1102 bus_done_private(m);
1103
1104 while ((c = set_steal_first(m->bus_connections)))
fae20b11 1105 shutdown_connection(m, c);
5e8d1c9a
LP		 1106
1107 while ((c = set_steal_first(m->bus_connections_for_dispatch)))
fae20b11 1108 shutdown_connection(m, c);
5e8d1c9a
LP		 1109
1110 set_free(m->bus_connections);
1111 set_free(m->bus_connections_for_dispatch);
1112
1113 if (m->name_data_slot >= 0)
1114 dbus_pending_call_free_data_slot(&m->name_data_slot);
a567261a
LP		 1115
1116 if (m->subscribed_data_slot >= 0)
d83685ac 1117 dbus_connection_free_data_slot(&m->subscribed_data_slot);
5e8d1c9a
LP		 1118}
1119
05e343b7
LP		 1120static void query_pid_pending_cb(DBusPendingCall *pending, void *userdata) {
1121 Manager *m = userdata;
1122 DBusMessage *reply;
1123 DBusError error;
1124 const char *name;
1125
1126 dbus_error_init(&error);
1127
a567261a 1128 assert_se(name = BUS_PENDING_CALL_NAME(m, pending));
05e343b7
LP		 1129 assert_se(reply = dbus_pending_call_steal_reply(pending));
1130
1131 switch (dbus_message_get_type(reply)) {
1132
1133 case DBUS_MESSAGE_TYPE_ERROR:
1134
1135 assert_se(dbus_set_error_from_message(&error, reply));
1136 log_warning("GetConnectionUnixProcessID() failed: %s", error.message);
1137 break;
1138
1139 case DBUS_MESSAGE_TYPE_METHOD_RETURN: {
1140 uint32_t r;
1141
1142 if (!dbus_message_get_args(reply,
1143 &error,
1144 DBUS_TYPE_UINT32, &r,
1145 DBUS_TYPE_INVALID)) {
1146 log_error("Failed to parse GetConnectionUnixProcessID() reply: %s", error.message);
1147 break;
1148 }
1149
1150 manager_dispatch_bus_query_pid_done(m, name, (pid_t) r);
1151 break;
1152 }
1153
1154 default:
1155 assert_not_reached("Invalid reply message");
1156 }
1157
1158 dbus_message_unref(reply);
1159 dbus_error_free(&error);
1160}
1161
1162int bus_query_pid(Manager *m, const char *name) {
1163 DBusMessage *message = NULL;
1164 DBusPendingCall *pending = NULL;
1165 char *n = NULL;
1166
1167 assert(m);
1168 assert(name);
1169
1170 if (!(message = dbus_message_new_method_call(
1171 DBUS_SERVICE_DBUS,
1172 DBUS_PATH_DBUS,
1173 DBUS_INTERFACE_DBUS,
1174 "GetConnectionUnixProcessID")))
1175 goto oom;
1176
1177 if (!(dbus_message_append_args(
1178 message,
1179 DBUS_TYPE_STRING, &name,
1180 DBUS_TYPE_INVALID)))
1181 goto oom;
1182
1183 if (!dbus_connection_send_with_reply(m->api_bus, message, &pending, -1))
1184 goto oom;
1185
1186 if (!(n = strdup(name)))
1187 goto oom;
1188
1189 if (!dbus_pending_call_set_data(pending, m->name_data_slot, n, free))
1190 goto oom;
1191
1192 n = NULL;
1193
1194 if (!dbus_pending_call_set_notify(pending, query_pid_pending_cb, m, NULL))
1195 goto oom;
1196
1197 dbus_message_unref(message);
1198 dbus_pending_call_unref(pending);
1199
1200 return 0;
1201
1202oom:
1203 free(n);
1204
1205 if (pending) {
1206 dbus_pending_call_cancel(pending);
1207 dbus_pending_call_unref(pending);
1208 }
1209
1210 if (message)
1211 dbus_message_unref(message);
1212
1213 return -ENOMEM;
1214}
1215
5e8d1c9a 1216DBusHandlerResult bus_default_message_handler(Manager *m, DBusConnection *c, DBusMessage *message, const char*introspection, const BusProperty *properties) {
ea430986
LP		 1217 DBusError error;
1218 DBusMessage *reply = NULL;
1219 int r;
1220
1221 assert(m);
1222 assert(message);
1223
1224 dbus_error_init(&error);
1225
1226 if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Introspectable", "Introspect") && introspection) {
1227
1228 if (!(reply = dbus_message_new_method_return(message)))
1229 goto oom;
1230
1231 if (!dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection, DBUS_TYPE_INVALID))
1232 goto oom;
1233
1234 } else if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Properties", "Get") && properties) {
1235 const char *interface, *property;
1236 const BusProperty *p;
1237
1238 if (!dbus_message_get_args(
1239 message,
1240 &error,
1241 DBUS_TYPE_STRING, &interface,
1242 DBUS_TYPE_STRING, &property,
1243 DBUS_TYPE_INVALID))
5e8d1c9a 1244 return bus_send_error_reply(m, c, message, &error, -EINVAL);
ea430986
LP		 1245
1246 for (p = properties; p->property; p++)
1247 if (streq(p->interface, interface) && streq(p->property, property))
1248 break;
1249
1250 if (p->property) {
1251 DBusMessageIter iter, sub;
1252
1253 if (!(reply = dbus_message_new_method_return(message)))
1254 goto oom;
1255
1256 dbus_message_iter_init_append(reply, &iter);
1257
1258 if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, p->signature, &sub))
1259 goto oom;
1260
b9f49ee4 1261 if ((r = p->append(m, &sub, property, (void*) p->data)) < 0) {
ea430986
LP		 1262
1263 if (r == -ENOMEM)
1264 goto oom;
1265
1266 dbus_message_unref(reply);
5e8d1c9a 1267 return bus_send_error_reply(m, c, message, NULL, r);
ea430986
LP		 1268 }
1269
1270 if (!dbus_message_iter_close_container(&iter, &sub))
1271 goto oom;
1272 }
c4e2ceae 1273
ea430986
LP		 1274 } else if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Properties", "GetAll") && properties) {
1275 const char *interface;
1276 const BusProperty *p;
1277 DBusMessageIter iter, sub, sub2, sub3;
ea430986
LP		 1278
1279 if (!dbus_message_get_args(
1280 message,
1281 &error,
1282 DBUS_TYPE_STRING, &interface,
1283 DBUS_TYPE_INVALID))
5e8d1c9a 1284 return bus_send_error_reply(m, c, message, &error, -EINVAL);
ea430986
LP		 1285
1286 if (!(reply = dbus_message_new_method_return(message)))
1287 goto oom;
1288
1289 dbus_message_iter_init_append(reply, &iter);
1290
1291 if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &sub))
1292 goto oom;
1293
1294 for (p = properties; p->property; p++) {
09c66196 1295 if (interface[0] && !streq(p->interface, interface))
ea430986
LP		 1296 continue;
1297
c401a1e0 1298 if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY, NULL, &sub2) ||
ea430986
LP		 1299 !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &p->property) ||
1300 !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, p->signature, &sub3))
1301 goto oom;
1302
b9f49ee4 1303 if ((r = p->append(m, &sub3, p->property, (void*) p->data)) < 0) {
ea430986
LP		 1304
1305 if (r == -ENOMEM)
1306 goto oom;
1307
1308 dbus_message_unref(reply);
5e8d1c9a 1309 return bus_send_error_reply(m, c, message, NULL, r);
ea430986
LP		 1310 }
1311
1312 if (!dbus_message_iter_close_container(&sub2, &sub3) ||
1313 !dbus_message_iter_close_container(&sub, &sub2))
1314 goto oom;
ea430986
LP		 1315 }
1316
1317 if (!dbus_message_iter_close_container(&iter, &sub))
1318 goto oom;
1319 }
1320
1321 if (reply) {
5e8d1c9a 1322 if (!dbus_connection_send(c, reply, NULL))
ea430986
LP		 1323 goto oom;
1324
1325 dbus_message_unref(reply);
1326 return DBUS_HANDLER_RESULT_HANDLED;
1327 }
1328
1329 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1330
1331oom:
1332 if (reply)
1333 dbus_message_unref(reply);
1334
1335 dbus_error_free(&error);
1336
1337 return DBUS_HANDLER_RESULT_NEED_MEMORY;
1338}
1339
ea430986
LP		 1340static const char *error_to_dbus(int error) {
1341
1342 switch(error) {
1343
1344 case -EINVAL:
1345 return DBUS_ERROR_INVALID_ARGS;
1346
1347 case -ENOMEM:
1348 return DBUS_ERROR_NO_MEMORY;
1349
1350 case -EPERM:
1351 case -EACCES:
1352 return DBUS_ERROR_ACCESS_DENIED;
1353
1354 case -ESRCH:
1355 return DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN;
1356
1357 case -ENOENT:
1358 return DBUS_ERROR_FILE_NOT_FOUND;
1359
1360 case -EEXIST:
1361 return DBUS_ERROR_FILE_EXISTS;
1362
1363 case -ETIMEDOUT:
1364 return DBUS_ERROR_TIMEOUT;
1365
1366 case -EIO:
1367 return DBUS_ERROR_IO_ERROR;
1368
1369 case -ENETRESET:
1370 case -ECONNABORTED:
1371 case -ECONNRESET:
1372 return DBUS_ERROR_DISCONNECTED;
1373 }
1374
1375 return DBUS_ERROR_FAILED;
1376}
1377
398ef8ba 1378DBusHandlerResult bus_send_error_reply(Manager *m, DBusConnection *c, DBusMessage *message, DBusError *berror, int error) {
ea430986
LP		 1379 DBusMessage *reply = NULL;
1380 const char *name, *text;
1381
398ef8ba
LP		 1382 if (berror && dbus_error_is_set(berror)) {
1383 name = berror->name;
1384 text = berror->message;
ea430986
LP		 1385 } else {
1386 name = error_to_dbus(error);
1387 text = strerror(-error);
1388 }
1389
1390 if (!(reply = dbus_message_new_error(message, name, text)))
1391 goto oom;
1392
5e8d1c9a 1393 if (!dbus_connection_send(c, reply, NULL))
ea430986
LP		 1394 goto oom;
1395
1396 dbus_message_unref(reply);
1397
398ef8ba
LP		 1398 if (berror)
1399 dbus_error_free(berror);
ea430986
LP		 1400
1401 return DBUS_HANDLER_RESULT_HANDLED;
1402
1403oom:
1404 if (reply)
1405 dbus_message_unref(reply);
1406
398ef8ba
LP		 1407 if (berror)
1408 dbus_error_free(berror);
ea430986
LP		 1409
1410 return DBUS_HANDLER_RESULT_NEED_MEMORY;
1411}
1412
5e8d1c9a
LP		 1413int bus_broadcast(Manager *m, DBusMessage *message) {
1414 bool oom = false;
1415 Iterator i;
1416 DBusConnection *c;
1417
1418 assert(m);
1419 assert(message);
1420
1421 SET_FOREACH(c, m->bus_connections_for_dispatch, i)
a3d4e06d 1422 if (c != m->system_bus || m->running_as == MANAGER_SYSTEM)
5e8d1c9a
LP		 1423 oom = !dbus_connection_send(c, message, NULL);
1424
1425 SET_FOREACH(c, m->bus_connections, i)
a3d4e06d 1426 if (c != m->system_bus || m->running_as == MANAGER_SYSTEM)
5e8d1c9a
LP		 1427 oom = !dbus_connection_send(c, message, NULL);
1428
1429 return oom ? -ENOMEM : 0;
1430}
1431
ea430986
LP		 1432int bus_property_append_string(Manager *m, DBusMessageIter *i, const char *property, void *data) {
1433 const char *t = data;
1434
1435 assert(m);
1436 assert(i);
1437 assert(property);
38131695
LP		 1438
1439 if (!t)
1440 t = "";
ea430986
LP		 1441
1442 if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &t))
1443 return -ENOMEM;
1444
1445 return 0;
1446}
1447
1448int bus_property_append_strv(Manager *m, DBusMessageIter *i, const char *property, void *data) {
1449 DBusMessageIter sub;
1450 char **t = data;
1451
1452 assert(m);
1453 assert(i);
1454 assert(property);
1455
1456 if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "s", &sub))
1457 return -ENOMEM;
1458
1459 STRV_FOREACH(t, t)
1460 if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, t))
1461 return -ENOMEM;
1462
1463 if (!dbus_message_iter_close_container(i, &sub))
1464 return -ENOMEM;
1465
1466 return 0;
1467}
1468
1469int bus_property_append_bool(Manager *m, DBusMessageIter *i, const char *property, void *data) {
1470 bool *b = data;
1471 dbus_bool_t db;
1472
1473 assert(m);
1474 assert(i);
1475 assert(property);
1476 assert(b);
1477
1478 db = *b;
1479
1480 if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &db))
1481 return -ENOMEM;
1482
1483 return 0;
1484}
38131695
LP		 1485
1486int bus_property_append_uint64(Manager *m, DBusMessageIter *i, const char *property, void *data) {
1487 assert(m);
1488 assert(i);
1489 assert(property);
1490 assert(data);
1491
4139c1b2
LP		 1492 /* Let's ensure that pid_t is actually 64bit, and hence this
1493 * function can be used for usec_t */
1494 assert_cc(sizeof(uint64_t) == sizeof(usec_t));
1495
38131695
LP		 1496 if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, data))
1497 return -ENOMEM;
1498
1499 return 0;
1500}
1501
1502int bus_property_append_uint32(Manager *m, DBusMessageIter *i, const char *property, void *data) {
1503 assert(m);
1504 assert(i);
1505 assert(property);
1506 assert(data);
1507
4139c1b2
LP		 1508 /* Let's ensure that pid_t and mode_t is actually 32bit, and
1509 * hence this function can be used for pid_t/mode_t */
1510 assert_cc(sizeof(uint32_t) == sizeof(pid_t));
1511 assert_cc(sizeof(uint32_t) == sizeof(mode_t));
1512 assert_cc(sizeof(uint32_t) == sizeof(unsigned));
1513
38131695
LP		 1514 if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT32, data))
1515 return -ENOMEM;
1516
1517 return 0;
1518}
4139c1b2
LP		 1519
1520int bus_property_append_int32(Manager *m, DBusMessageIter *i, const char *property, void *data) {
1521 assert(m);
1522 assert(i);
1523 assert(property);
1524 assert(data);
1525
1526 assert_cc(sizeof(int32_t) == sizeof(int));
1527
1528 if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, data))
1529 return -ENOMEM;
1530
1531 return 0;
1532}
1137a57c 1533
4fd5948e
LP		 1534int bus_property_append_size(Manager *m, DBusMessageIter *i, const char *property, void *data) {
1535 uint64_t u;
1536
1537 assert(m);
1538 assert(i);
1539 assert(property);
1540 assert(data);
1541
1542 u = (uint64_t) *(size_t*) data;
1543
1544 if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &u))
1545 return -ENOMEM;
1546
1547 return 0;
1548}
1549
82c121a4
LP		 1550int bus_property_append_ul(Manager *m, DBusMessageIter *i, const char *property, void *data) {
1551 uint64_t u;
1552
1553 assert(m);
1554 assert(i);
1555 assert(property);
1556 assert(data);
1557
1558 u = (uint64_t) *(unsigned long*) data;
1559
1560 if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &u))
1561 return -ENOMEM;
1562
1563 return 0;
1564}
1565
1137a57c
LP		 1566int bus_parse_strv(DBusMessage *m, char ***_l) {
1567 DBusMessageIter iter, sub;
1568 unsigned n = 0, i = 0;
1569 char **l;
1570
1571 assert(m);
1572 assert(_l);
1573
1574 if (!dbus_message_iter_init(m, &iter) ||
1575 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
1576 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRING)
1577 return -EINVAL;
1578
1579 dbus_message_iter_recurse(&iter, &sub);
1580
1581 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
1582 n++;
1583 dbus_message_iter_next(&sub);
1584 }
1585
1586 if (!(l = new(char*, n+1)))
1587 return -ENOMEM;
1588
1589 assert_se(dbus_message_iter_init(m, &iter));
1590 dbus_message_iter_recurse(&iter, &sub);
1591
1592 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
1593 const char *s;
1594
1595 assert_se(dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING);
1596 dbus_message_iter_get_basic(&sub, &s);
1597
1598 if (!(l[i++] = strdup(s))) {
1599 strv_free(l);
1600 return -ENOMEM;
1601 }
1602
1603 dbus_message_iter_next(&sub);
1604 }
1605
1606 assert(i == n);
1607 l[i] = NULL;
1608
1609 if (_l)
1610 *_l = l;
1611
1612 return 0;
1613}
a567261a
LP		 1614
1615bool bus_has_subscriber(Manager *m) {
1616 Iterator i;
1617 DBusConnection *c;
1618
1619 assert(m);
1620
1621 SET_FOREACH(c, m->bus_connections_for_dispatch, i)
1622 if (bus_connection_has_subscriber(m, c))
1623 return true;
1624
1625 SET_FOREACH(c, m->bus_connections, i)
1626 if (bus_connection_has_subscriber(m, c))
1627 return true;
1628
1629 return false;
1630}
1631
1632bool bus_connection_has_subscriber(Manager *m, DBusConnection *c) {
1633 assert(m);
1634 assert(c);
1635
1636 return !set_isempty(BUS_CONNECTION_SUBSCRIBED(m, c));
1637}
c4e2ceae
LP		 1638
1639DBusMessage* bus_properties_changed_new(const char *path, const char *interface, const char *properties) {
1640 DBusMessage *m;
1641 DBusMessageIter iter, sub;
1642 const char *i;
1643
1644 assert(interface);
1645 assert(properties);
1646
1647 if (!(m = dbus_message_new_signal(path, "org.freedesktop.DBus.Properties", "PropertiesChanged")))
1648 goto oom;
1649
1650 dbus_message_iter_init_append(m, &iter);
1651
1652 /* We won't send any property values, since they might be
1653 * large and sometimes not cheap to generated */
1654
1655 if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &interface) ||
1656 !dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &sub) ||
1657 !dbus_message_iter_close_container(&iter, &sub) ||
1658 !dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub))
1659 goto oom;
1660
1661 NULSTR_FOREACH(i, properties)
1662 if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &i))
1663 goto oom;
1664
1665 if (!dbus_message_iter_close_container(&iter, &sub))
1666 goto oom;
1667
1668 return m;
1669
1670oom:
1671 if (m)
1672 dbus_message_unref(m);
1673
1674 return NULL;
1675}
Unnamed repository; edit this file 'description' to name the repository.