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 };