chiark / gitweb /
dbus: export ControlGroupPersistent field on the bus again
[elogind.git] / src / dbus-unit.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
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
22 #include <errno.h>
23
24 #include "dbus.h"
25 #include "log.h"
26 #include "dbus-unit.h"
27 #include "bus-errors.h"
28 #include "dbus-common.h"
29
30 const char bus_unit_interface[] _introspect_("Unit") = BUS_UNIT_INTERFACE;
31
32 #define INVALIDATING_PROPERTIES                 \
33         "LoadState\0"                           \
34         "ActiveState\0"                         \
35         "SubState\0"                            \
36         "InactiveExitTimestamp\0"               \
37         "ActiveEnterTimestamp\0"                \
38         "ActiveExitTimestamp\0"                 \
39         "InactiveEnterTimestamp\0"              \
40         "Job\0"                                 \
41         "NeedDaemonReload\0"
42
43 static int bus_unit_append_names(DBusMessageIter *i, const char *property, void *data) {
44         char *t;
45         Iterator j;
46         DBusMessageIter sub;
47         Unit *u = data;
48
49         if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "s", &sub))
50                 return -ENOMEM;
51
52         SET_FOREACH(t, u->names, j)
53                 if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &t))
54                         return -ENOMEM;
55
56         if (!dbus_message_iter_close_container(i, &sub))
57                 return -ENOMEM;
58
59         return 0;
60 }
61
62 static int bus_unit_append_following(DBusMessageIter *i, const char *property, void *data) {
63         Unit *u = data, *f;
64         const char *d;
65
66         assert(i);
67         assert(property);
68         assert(u);
69
70         f = unit_following(u);
71         d = f ? f->id : "";
72
73         if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &d))
74                 return -ENOMEM;
75
76         return 0;
77 }
78
79 static int bus_unit_append_dependencies(DBusMessageIter *i, const char *property, void *data) {
80         Unit *u;
81         Iterator j;
82         DBusMessageIter sub;
83         Set *s = data;
84
85         if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "s", &sub))
86                 return -ENOMEM;
87
88         SET_FOREACH(u, s, j)
89                 if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &u->id))
90                         return -ENOMEM;
91
92         if (!dbus_message_iter_close_container(i, &sub))
93                 return -ENOMEM;
94
95         return 0;
96 }
97
98 static int bus_unit_append_description(DBusMessageIter *i, const char *property, void *data) {
99         Unit *u = data;
100         const char *d;
101
102         assert(i);
103         assert(property);
104         assert(u);
105
106         d = unit_description(u);
107
108         if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &d))
109                 return -ENOMEM;
110
111         return 0;
112 }
113
114 static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_unit_append_load_state, unit_load_state, UnitLoadState);
115
116 static int bus_unit_append_active_state(DBusMessageIter *i, const char *property, void *data) {
117         Unit *u = data;
118         const char *state;
119
120         assert(i);
121         assert(property);
122         assert(u);
123
124         state = unit_active_state_to_string(unit_active_state(u));
125
126         if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &state))
127                 return -ENOMEM;
128
129         return 0;
130 }
131
132 static int bus_unit_append_sub_state(DBusMessageIter *i, const char *property, void *data) {
133         Unit *u = data;
134         const char *state;
135
136         assert(i);
137         assert(property);
138         assert(u);
139
140         state = unit_sub_state_to_string(u);
141
142         if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &state))
143                 return -ENOMEM;
144
145         return 0;
146 }
147
148 static int bus_unit_append_file_state(DBusMessageIter *i, const char *property, void *data) {
149         Unit *u = data;
150         const char *state;
151
152         assert(i);
153         assert(property);
154         assert(u);
155
156         state = strempty(unit_file_state_to_string(unit_get_unit_file_state(u)));
157
158         if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &state))
159                 return -ENOMEM;
160
161         return 0;
162 }
163
164 static int bus_unit_append_can_start(DBusMessageIter *i, const char *property, void *data) {
165         Unit *u = data;
166         dbus_bool_t b;
167
168         assert(i);
169         assert(property);
170         assert(u);
171
172         b = unit_can_start(u) &&
173                 !u->refuse_manual_start;
174
175         if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
176                 return -ENOMEM;
177
178         return 0;
179 }
180
181 static int bus_unit_append_can_stop(DBusMessageIter *i, const char *property, void *data) {
182         Unit *u = data;
183         dbus_bool_t b;
184
185         assert(i);
186         assert(property);
187         assert(u);
188
189         /* On the lower levels we assume that every unit we can start
190          * we can also stop */
191
192         b = unit_can_start(u) &&
193                 !u->refuse_manual_stop;
194
195         if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
196                 return -ENOMEM;
197
198         return 0;
199 }
200
201 static int bus_unit_append_can_reload(DBusMessageIter *i, const char *property, void *data) {
202         Unit *u = data;
203         dbus_bool_t b;
204
205         assert(i);
206         assert(property);
207         assert(u);
208
209         b = unit_can_reload(u);
210
211         if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
212                 return -ENOMEM;
213
214         return 0;
215 }
216
217 static int bus_unit_append_can_isolate(DBusMessageIter *i, const char *property, void *data) {
218         Unit *u = data;
219         dbus_bool_t b;
220
221         assert(i);
222         assert(property);
223         assert(u);
224
225         b = unit_can_isolate(u) &&
226                 !u->refuse_manual_start;
227
228         if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
229                 return -ENOMEM;
230
231         return 0;
232 }
233
234 static int bus_unit_append_job(DBusMessageIter *i, const char *property, void *data) {
235         Unit *u = data;
236         DBusMessageIter sub;
237         char *p;
238
239         assert(i);
240         assert(property);
241         assert(u);
242
243         if (!dbus_message_iter_open_container(i, DBUS_TYPE_STRUCT, NULL, &sub))
244                 return -ENOMEM;
245
246         if (u->job) {
247
248                 if (!(p = job_dbus_path(u->job)))
249                         return -ENOMEM;
250
251                 if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &u->job->id) ||
252                     !dbus_message_iter_append_basic(&sub, DBUS_TYPE_OBJECT_PATH, &p)) {
253                         free(p);
254                         return -ENOMEM;
255                 }
256         } else {
257                 uint32_t id = 0;
258
259                 /* No job, so let's fill in some placeholder
260                  * data. Since we need to fill in a valid path we
261                  * simple point to ourselves. */
262
263                 if (!(p = unit_dbus_path(u)))
264                         return -ENOMEM;
265
266                 if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &id) ||
267                     !dbus_message_iter_append_basic(&sub, DBUS_TYPE_OBJECT_PATH, &p)) {
268                         free(p);
269                         return -ENOMEM;
270                 }
271         }
272
273         free(p);
274
275         if (!dbus_message_iter_close_container(i, &sub))
276                 return -ENOMEM;
277
278         return 0;
279 }
280
281 static int bus_unit_append_default_cgroup(DBusMessageIter *i, const char *property, void *data) {
282         Unit *u = data;
283         char *t;
284         CGroupBonding *cgb;
285         bool success;
286
287         assert(i);
288         assert(property);
289         assert(u);
290
291         if ((cgb = unit_get_default_cgroup(u))) {
292                 if (!(t = cgroup_bonding_to_string(cgb)))
293                         return -ENOMEM;
294         } else
295                 t = (char*) "";
296
297         success = dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &t);
298
299         if (cgb)
300                 free(t);
301
302         return success ? 0 : -ENOMEM;
303 }
304
305 static int bus_unit_append_cgroups(DBusMessageIter *i, const char *property, void *data) {
306         Unit *u = data;
307         CGroupBonding *cgb;
308         DBusMessageIter sub;
309
310         if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "s", &sub))
311                 return -ENOMEM;
312
313         LIST_FOREACH(by_unit, cgb, u->cgroup_bondings) {
314                 char *t;
315                 bool success;
316
317                 if (!(t = cgroup_bonding_to_string(cgb)))
318                         return -ENOMEM;
319
320                 success = dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &t);
321                 free(t);
322
323                 if (!success)
324                         return -ENOMEM;
325         }
326
327         if (!dbus_message_iter_close_container(i, &sub))
328                 return -ENOMEM;
329
330         return 0;
331 }
332
333 static int bus_unit_append_cgroup_attrs(DBusMessageIter *i, const char *property, void *data) {
334         Unit *u = data;
335         CGroupAttribute *a;
336         DBusMessageIter sub, sub2;
337
338         if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "(sss)", &sub))
339                 return -ENOMEM;
340
341         LIST_FOREACH(by_unit, a, u->cgroup_attributes) {
342                 char *v = NULL;
343                 bool success;
344
345                 if (a->map_callback)
346                         a->map_callback(a->controller, a->name, a->value, &v);
347
348                 success =
349                         dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) &&
350                         dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &a->controller) &&
351                         dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &a->name) &&
352                         dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, v ? &v : &a->value) &&
353                         dbus_message_iter_close_container(&sub, &sub2);
354
355                 free(v);
356
357                 if (!success)
358                         return -ENOMEM;
359         }
360
361         if (!dbus_message_iter_close_container(i, &sub))
362                 return -ENOMEM;
363
364         return 0;
365 }
366
367 static int bus_unit_append_need_daemon_reload(DBusMessageIter *i, const char *property, void *data) {
368         Unit *u = data;
369         dbus_bool_t b;
370
371         assert(i);
372         assert(property);
373         assert(u);
374
375         b = unit_need_daemon_reload(u);
376
377         if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
378                 return -ENOMEM;
379
380         return 0;
381 }
382
383 static int bus_unit_append_load_error(DBusMessageIter *i, const char *property, void *data) {
384         Unit *u = data;
385         const char *name, *message;
386         DBusMessageIter sub;
387
388         assert(i);
389         assert(property);
390         assert(u);
391
392         if (u->load_error != 0) {
393                 name = bus_errno_to_dbus(u->load_error);
394                 message = strempty(strerror(-u->load_error));
395         } else
396                 name = message = "";
397
398         if (!dbus_message_iter_open_container(i, DBUS_TYPE_STRUCT, NULL, &sub) ||
399             !dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &name) ||
400             !dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &message) ||
401             !dbus_message_iter_close_container(i, &sub))
402                 return -ENOMEM;
403
404         return 0;
405 }
406
407 static DBusHandlerResult bus_unit_message_dispatch(Unit *u, DBusConnection *connection, DBusMessage *message) {
408         DBusMessage *reply = NULL;
409         Manager *m = u->manager;
410         DBusError error;
411         JobType job_type = _JOB_TYPE_INVALID;
412         char *path = NULL;
413         bool reload_if_possible = false;
414
415         dbus_error_init(&error);
416
417         if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Unit", "Start"))
418                 job_type = JOB_START;
419         else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Unit", "Stop"))
420                 job_type = JOB_STOP;
421         else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Unit", "Reload"))
422                 job_type = JOB_RELOAD;
423         else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Unit", "Restart"))
424                 job_type = JOB_RESTART;
425         else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Unit", "TryRestart"))
426                 job_type = JOB_TRY_RESTART;
427         else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Unit", "ReloadOrRestart")) {
428                 reload_if_possible = true;
429                 job_type = JOB_RESTART;
430         } else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Unit", "ReloadOrTryRestart")) {
431                 reload_if_possible = true;
432                 job_type = JOB_TRY_RESTART;
433         } else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Unit", "Kill")) {
434                 const char *swho, *smode;
435                 int32_t signo;
436                 KillMode mode;
437                 KillWho who;
438                 int r;
439
440                 if (!dbus_message_get_args(
441                                     message,
442                                     &error,
443                                     DBUS_TYPE_STRING, &swho,
444                                     DBUS_TYPE_STRING, &smode,
445                                     DBUS_TYPE_INT32, &signo,
446                                     DBUS_TYPE_INVALID))
447                         return bus_send_error_reply(connection, message, &error, -EINVAL);
448
449                 if (isempty(swho))
450                         who = KILL_ALL;
451                 else {
452                         who = kill_who_from_string(swho);
453                         if (who < 0)
454                                 return bus_send_error_reply(connection, message, &error, -EINVAL);
455                 }
456
457                 if (isempty(smode))
458                         mode = KILL_CONTROL_GROUP;
459                 else {
460                         mode = kill_mode_from_string(smode);
461                         if (mode < 0)
462                                 return bus_send_error_reply(connection, message, &error, -EINVAL);
463                 }
464
465                 if (signo <= 0 || signo >= _NSIG)
466                         return bus_send_error_reply(connection, message, &error, -EINVAL);
467
468                 if ((r = unit_kill(u, who, mode, signo, &error)) < 0)
469                         return bus_send_error_reply(connection, message, &error, r);
470
471                 if (!(reply = dbus_message_new_method_return(message)))
472                         goto oom;
473
474         } else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Unit", "ResetFailed")) {
475
476                 unit_reset_failed(u);
477
478                 if (!(reply = dbus_message_new_method_return(message)))
479                         goto oom;
480
481         } else if (UNIT_VTABLE(u)->bus_message_handler)
482                 return UNIT_VTABLE(u)->bus_message_handler(u, connection, message);
483         else
484                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
485
486         if (job_type != _JOB_TYPE_INVALID) {
487                 const char *smode;
488                 JobMode mode;
489                 Job *j;
490                 int r;
491
492                 if ((job_type == JOB_START && u->refuse_manual_start) ||
493                     (job_type == JOB_STOP && u->refuse_manual_stop) ||
494                     ((job_type == JOB_RESTART || job_type == JOB_TRY_RESTART) &&
495                      (u->refuse_manual_start || u->refuse_manual_stop))) {
496                         dbus_set_error(&error, BUS_ERROR_ONLY_BY_DEPENDENCY, "Operation refused, may be requested by dependency only.");
497                         return bus_send_error_reply(connection, message, &error, -EPERM);
498                 }
499
500                 if (!dbus_message_get_args(
501                                     message,
502                                     &error,
503                                     DBUS_TYPE_STRING, &smode,
504                                     DBUS_TYPE_INVALID))
505                         return bus_send_error_reply(connection, message, &error, -EINVAL);
506
507                 if (reload_if_possible && unit_can_reload(u)) {
508                         if (job_type == JOB_RESTART)
509                                 job_type = JOB_RELOAD_OR_START;
510                         else if (job_type == JOB_TRY_RESTART)
511                                 job_type = JOB_RELOAD;
512                 }
513
514                 if ((mode = job_mode_from_string(smode)) == _JOB_MODE_INVALID) {
515                         dbus_set_error(&error, BUS_ERROR_INVALID_JOB_MODE, "Job mode %s is invalid.", smode);
516                         return bus_send_error_reply(connection, message, &error, -EINVAL);
517                 }
518
519                 if ((r = manager_add_job(m, job_type, u, mode, true, &error, &j)) < 0)
520                         return bus_send_error_reply(connection, message, &error, r);
521
522                 if (!(reply = dbus_message_new_method_return(message)))
523                         goto oom;
524
525                 if (!(path = job_dbus_path(j)))
526                         goto oom;
527
528                 if (!dbus_message_append_args(
529                                     reply,
530                                     DBUS_TYPE_OBJECT_PATH, &path,
531                                     DBUS_TYPE_INVALID))
532                         goto oom;
533         }
534
535         if (reply) {
536                 if (!dbus_connection_send(connection, reply, NULL))
537                         goto oom;
538
539                 dbus_message_unref(reply);
540         }
541
542         free(path);
543
544         return DBUS_HANDLER_RESULT_HANDLED;
545
546 oom:
547         free(path);
548
549         if (reply)
550                 dbus_message_unref(reply);
551
552         dbus_error_free(&error);
553
554         return DBUS_HANDLER_RESULT_NEED_MEMORY;
555 }
556
557 static DBusHandlerResult bus_unit_message_handler(DBusConnection *connection, DBusMessage  *message, void *data) {
558         Manager *m = data;
559         Unit *u;
560         int r;
561         DBusMessage *reply;
562
563         assert(connection);
564         assert(message);
565         assert(m);
566
567         if (streq(dbus_message_get_path(message), "/org/freedesktop/systemd1/unit")) {
568                 /* Be nice to gdbus and return introspection data for our mid-level paths */
569
570                 if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Introspectable", "Introspect")) {
571                         char *introspection = NULL;
572                         FILE *f;
573                         Iterator i;
574                         const char *k;
575                         size_t size;
576
577                         if (!(reply = dbus_message_new_method_return(message)))
578                                 goto oom;
579
580                         /* We roll our own introspection code here, instead of
581                          * relying on bus_default_message_handler() because we
582                          * need to generate our introspection string
583                          * dynamically. */
584
585                         if (!(f = open_memstream(&introspection, &size)))
586                                 goto oom;
587
588                         fputs(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE
589                               "<node>\n", f);
590
591                         fputs(BUS_INTROSPECTABLE_INTERFACE, f);
592                         fputs(BUS_PEER_INTERFACE, f);
593
594                         HASHMAP_FOREACH_KEY(u, k, m->units, i) {
595                                 char *p;
596
597                                 if (k != u->id)
598                                         continue;
599
600                                 if (!(p = bus_path_escape(k))) {
601                                         fclose(f);
602                                         free(introspection);
603                                         goto oom;
604                                 }
605
606                                 fprintf(f, "<node name=\"%s\"/>", p);
607                                 free(p);
608                         }
609
610                         fputs("</node>\n", f);
611
612                         if (ferror(f)) {
613                                 fclose(f);
614                                 free(introspection);
615                                 goto oom;
616                         }
617
618                         fclose(f);
619
620                         if (!introspection)
621                                 goto oom;
622
623                         if (!dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection, DBUS_TYPE_INVALID)) {
624                                 free(introspection);
625                                 goto oom;
626                         }
627
628                         free(introspection);
629
630                         if (!dbus_connection_send(connection, reply, NULL))
631                                 goto oom;
632
633                         dbus_message_unref(reply);
634
635                         return DBUS_HANDLER_RESULT_HANDLED;
636                 }
637
638                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
639         }
640
641         if ((r = manager_get_unit_from_dbus_path(m, dbus_message_get_path(message), &u)) < 0) {
642
643                 if (r == -ENOMEM)
644                         return DBUS_HANDLER_RESULT_NEED_MEMORY;
645
646                 if (r == -ENOENT) {
647                         DBusError e;
648
649                         dbus_error_init(&e);
650                         dbus_set_error_const(&e, DBUS_ERROR_UNKNOWN_OBJECT, "Unknown unit");
651                         return bus_send_error_reply(connection, message, &e, r);
652                 }
653
654                 return bus_send_error_reply(connection, message, NULL, r);
655         }
656
657         return bus_unit_message_dispatch(u, connection, message);
658
659 oom:
660         if (reply)
661                 dbus_message_unref(reply);
662
663         return DBUS_HANDLER_RESULT_NEED_MEMORY;
664 }
665
666 const DBusObjectPathVTable bus_unit_vtable = {
667         .message_function = bus_unit_message_handler
668 };
669
670 void bus_unit_send_change_signal(Unit *u) {
671         char *p = NULL;
672         DBusMessage *m = NULL;
673
674         assert(u);
675
676         if (u->in_dbus_queue) {
677                 LIST_REMOVE(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
678                 u->in_dbus_queue = false;
679         }
680
681         if (!u->id)
682                 return;
683
684         if (!bus_has_subscriber(u->manager)) {
685                 u->sent_dbus_new_signal = true;
686                 return;
687         }
688
689         if (!(p = unit_dbus_path(u)))
690                 goto oom;
691
692         if (u->sent_dbus_new_signal) {
693                 /* Send a properties changed signal. First for the
694                  * specific type, then for the generic unit. The
695                  * clients may rely on this order to get atomic
696                  * behaviour if needed. */
697
698                 if (UNIT_VTABLE(u)->bus_invalidating_properties) {
699
700                         if (!(m = bus_properties_changed_new(p,
701                                                              UNIT_VTABLE(u)->bus_interface,
702                                                              UNIT_VTABLE(u)->bus_invalidating_properties)))
703                                 goto oom;
704
705                         if (bus_broadcast(u->manager, m) < 0)
706                                 goto oom;
707
708                         dbus_message_unref(m);
709                 }
710
711                 if (!(m = bus_properties_changed_new(p, "org.freedesktop.systemd1.Unit", INVALIDATING_PROPERTIES)))
712                         goto oom;
713
714         } else {
715                 /* Send a new signal */
716
717                 if (!(m = dbus_message_new_signal("/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "UnitNew")))
718                         goto oom;
719
720                 if (!dbus_message_append_args(m,
721                                               DBUS_TYPE_STRING, &u->id,
722                                               DBUS_TYPE_OBJECT_PATH, &p,
723                                               DBUS_TYPE_INVALID))
724                         goto oom;
725         }
726
727         if (bus_broadcast(u->manager, m) < 0)
728                 goto oom;
729
730         free(p);
731         dbus_message_unref(m);
732
733         u->sent_dbus_new_signal = true;
734
735         return;
736
737 oom:
738         free(p);
739
740         if (m)
741                 dbus_message_unref(m);
742
743         log_error("Failed to allocate unit change/new signal.");
744 }
745
746 void bus_unit_send_removed_signal(Unit *u) {
747         char *p = NULL;
748         DBusMessage *m = NULL;
749
750         assert(u);
751
752         if (!bus_has_subscriber(u->manager))
753                 return;
754
755         if (!u->sent_dbus_new_signal)
756                 bus_unit_send_change_signal(u);
757
758         if (!u->id)
759                 return;
760
761         if (!(p = unit_dbus_path(u)))
762                 goto oom;
763
764         if (!(m = dbus_message_new_signal("/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "UnitRemoved")))
765                 goto oom;
766
767         if (!dbus_message_append_args(m,
768                                       DBUS_TYPE_STRING, &u->id,
769                                       DBUS_TYPE_OBJECT_PATH, &p,
770                                       DBUS_TYPE_INVALID))
771                 goto oom;
772
773         if (bus_broadcast(u->manager, m) < 0)
774                 goto oom;
775
776         free(p);
777         dbus_message_unref(m);
778
779         return;
780
781 oom:
782         free(p);
783
784         if (m)
785                 dbus_message_unref(m);
786
787         log_error("Failed to allocate unit remove signal.");
788 }
789
790 const BusProperty bus_unit_properties[] = {
791         { "Id",                   bus_property_append_string,         "s", offsetof(Unit, id),                                         true },
792         { "Names",                bus_unit_append_names,             "as", 0 },
793         { "Following",            bus_unit_append_following,          "s", 0 },
794         { "Requires",             bus_unit_append_dependencies,      "as", offsetof(Unit, dependencies[UNIT_REQUIRES]),                true },
795         { "RequiresOverridable",  bus_unit_append_dependencies,      "as", offsetof(Unit, dependencies[UNIT_REQUIRES_OVERRIDABLE]),    true },
796         { "Requisite",            bus_unit_append_dependencies,      "as", offsetof(Unit, dependencies[UNIT_REQUISITE]),               true },
797         { "RequisiteOverridable", bus_unit_append_dependencies,      "as", offsetof(Unit, dependencies[UNIT_REQUISITE_OVERRIDABLE]),   true },
798         { "Wants",                bus_unit_append_dependencies,      "as", offsetof(Unit, dependencies[UNIT_WANTS]),                   true },
799         { "BindTo",               bus_unit_append_dependencies,      "as", offsetof(Unit, dependencies[UNIT_BIND_TO]),                 true },
800         { "RequiredBy",           bus_unit_append_dependencies,      "as", offsetof(Unit, dependencies[UNIT_REQUIRED_BY]),             true },
801         { "RequiredByOverridable",bus_unit_append_dependencies,      "as", offsetof(Unit, dependencies[UNIT_REQUIRED_BY_OVERRIDABLE]), true },
802         { "WantedBy",             bus_unit_append_dependencies,      "as", offsetof(Unit, dependencies[UNIT_WANTED_BY]),               true },
803         { "BoundBy",              bus_unit_append_dependencies,      "as", offsetof(Unit, dependencies[UNIT_BOUND_BY]),                true },
804         { "Conflicts",            bus_unit_append_dependencies,      "as", offsetof(Unit, dependencies[UNIT_CONFLICTS]),               true },
805         { "ConflictedBy",         bus_unit_append_dependencies,      "as", offsetof(Unit, dependencies[UNIT_CONFLICTED_BY]),           true },
806         { "Before",               bus_unit_append_dependencies,      "as", offsetof(Unit, dependencies[UNIT_BEFORE]),                  true },
807         { "After",                bus_unit_append_dependencies,      "as", offsetof(Unit, dependencies[UNIT_AFTER]),                   true },
808         { "OnFailure",            bus_unit_append_dependencies,      "as", offsetof(Unit, dependencies[UNIT_ON_FAILURE]),              true },
809         { "Triggers",             bus_unit_append_dependencies,      "as", offsetof(Unit, dependencies[UNIT_TRIGGERS]),                true },
810         { "TriggeredBy",          bus_unit_append_dependencies,      "as", offsetof(Unit, dependencies[UNIT_TRIGGERED_BY]),            true },
811         { "PropagateReloadTo",    bus_unit_append_dependencies,      "as", offsetof(Unit, dependencies[UNIT_PROPAGATE_RELOAD_TO]),     true },
812         { "PropagateReloadFrom",  bus_unit_append_dependencies,      "as", offsetof(Unit, dependencies[UNIT_PROPAGATE_RELOAD_FROM]),   true },
813         { "Description",          bus_unit_append_description,        "s", 0 },
814         { "LoadState",            bus_unit_append_load_state,         "s", offsetof(Unit, load_state)                         },
815         { "ActiveState",          bus_unit_append_active_state,       "s", 0 },
816         { "SubState",             bus_unit_append_sub_state,          "s", 0 },
817         { "FragmentPath",         bus_property_append_string,         "s", offsetof(Unit, fragment_path),                              true },
818         { "UnitFileState",        bus_unit_append_file_state,         "s", 0 },
819         { "InactiveExitTimestamp",bus_property_append_usec,           "t", offsetof(Unit, inactive_exit_timestamp.realtime)   },
820         { "InactiveExitTimestampMonotonic", bus_property_append_usec, "t", offsetof(Unit, inactive_exit_timestamp.monotonic)  },
821         { "ActiveEnterTimestamp", bus_property_append_usec,           "t", offsetof(Unit, active_enter_timestamp.realtime)    },
822         { "ActiveEnterTimestampMonotonic", bus_property_append_usec,  "t", offsetof(Unit, active_enter_timestamp.monotonic)   },
823         { "ActiveExitTimestamp",  bus_property_append_usec,           "t", offsetof(Unit, active_exit_timestamp.realtime)     },
824         { "ActiveExitTimestampMonotonic",  bus_property_append_usec,  "t", offsetof(Unit, active_exit_timestamp.monotonic)    },
825         { "InactiveEnterTimestamp", bus_property_append_usec,         "t", offsetof(Unit, inactive_enter_timestamp.realtime)  },
826         { "InactiveEnterTimestampMonotonic",bus_property_append_usec, "t", offsetof(Unit, inactive_enter_timestamp.monotonic) },
827         { "CanStart",             bus_unit_append_can_start,          "b", 0 },
828         { "CanStop",              bus_unit_append_can_stop,           "b", 0 },
829         { "CanReload",            bus_unit_append_can_reload,         "b", 0 },
830         { "CanIsolate",           bus_unit_append_can_isolate,        "b", 0 },
831         { "Job",                  bus_unit_append_job,             "(uo)", 0 },
832         { "StopWhenUnneeded",     bus_property_append_bool,           "b", offsetof(Unit, stop_when_unneeded)                 },
833         { "RefuseManualStart",    bus_property_append_bool,           "b", offsetof(Unit, refuse_manual_start)                },
834         { "RefuseManualStop",     bus_property_append_bool,           "b", offsetof(Unit, refuse_manual_stop)                 },
835         { "AllowIsolate",         bus_property_append_bool,           "b", offsetof(Unit, allow_isolate)                      },
836         { "DefaultDependencies",  bus_property_append_bool,           "b", offsetof(Unit, default_dependencies)               },
837         { "OnFailureIsolate",     bus_property_append_bool,           "b", offsetof(Unit, on_failure_isolate)                 },
838         { "IgnoreOnIsolate",      bus_property_append_bool,           "b", offsetof(Unit, ignore_on_isolate)                  },
839         { "IgnoreOnSnapshot",     bus_property_append_bool,           "b", offsetof(Unit, ignore_on_snapshot)                 },
840         { "DefaultControlGroup",  bus_unit_append_default_cgroup,     "s", 0 },
841         { "ControlGroup",         bus_unit_append_cgroups,           "as", 0 },
842         { "ControlGroupAttributes", bus_unit_append_cgroup_attrs,"a(sss)", 0 },
843         { "NeedDaemonReload",     bus_unit_append_need_daemon_reload, "b", 0 },
844         { "JobTimeoutUSec",       bus_property_append_usec,           "t", offsetof(Unit, job_timeout)                        },
845         { "ConditionTimestamp",   bus_property_append_usec,           "t", offsetof(Unit, condition_timestamp.realtime)       },
846         { "ConditionTimestampMonotonic", bus_property_append_usec,    "t", offsetof(Unit, condition_timestamp.monotonic)      },
847         { "ConditionResult",      bus_property_append_bool,           "b", offsetof(Unit, condition_result)                   },
848         { "LoadError",            bus_unit_append_load_error,      "(ss)", 0 },
849         { NULL, }
850 };