src/machine/machined-dbus.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2011 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 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   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <errno.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <pwd.h>
  26 #include <sys/capability.h>
  27
  28 #include "sd-id128.h"
  29 #include "sd-messages.h"
  30 #include "strv.h"
  31 #include "mkdir.h"
  32 #include "path-util.h"
  33 #include "special.h"
  34 #include "fileio-label.h"
  35 #include "label.h"
  36 #include "utf8.h"
  37 #include "unit-name.h"
  38 #include "bus-util.h"
  39 #include "bus-errors.h"
  40 #include "time-util.h"
  41 #include "cgroup-util.h"
  42 #include "machined.h"
  43
  44 static int method_get_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
  45         _cleanup_free_ char *p = NULL;
  46         Manager *m = userdata;
  47         Machine *machine;
  48         const char *name;
  49         int r;
  50
  51         assert(bus);
  52         assert(message);
  53         assert(m);
  54
  55         r = sd_bus_message_read(message, "s", &name);
  56         if (r < 0)
  57                 return r;
  58
  59         machine = hashmap_get(m->machines, name);
  60         if (!machine)
  61                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
  62
  63         p = machine_bus_path(machine);
  64         if (!p)
  65                 return -ENOMEM;
  66
  67         return sd_bus_reply_method_return(message, "o", p);
  68 }
  69
  70 static int method_get_machine_by_pid(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
  71         _cleanup_free_ char *p = NULL;
  72         Manager *m = userdata;
  73         Machine *machine = NULL;
  74         pid_t pid;
  75         int r;
  76
  77         assert(bus);
  78         assert(message);
  79         assert(m);
  80
  81         assert_cc(sizeof(pid_t) == sizeof(uint32_t));
  82
  83         r = sd_bus_message_read(message, "u", &pid);
  84         if (r < 0)
  85                 return r;
  86
  87         if (pid == 0) {
  88                 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
  89
  90                 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
  91                 if (r < 0)
  92                         return r;
  93
  94                 r = sd_bus_creds_get_pid(creds, &pid);
  95                 if (r < 0)
  96                         return r;
  97         }
  98
  99         r = manager_get_machine_by_pid(m, pid, &machine);
 100         if (r < 0)
 101                 return r;
 102         if (!machine)
 103                 return sd_bus_error_setf(error, BUS_ERROR_NO_MACHINE_FOR_PID, "PID "PID_FMT" does not belong to any known machine", pid);
 104
 105         p = machine_bus_path(machine);
 106         if (!p)
 107                 return -ENOMEM;
 108
 109         return sd_bus_reply_method_return(message, "o", p);
 110 }
 111
 112 static int method_list_machines(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
 113         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
 114         Manager *m = userdata;
 115         Machine *machine;
 116         Iterator i;
 117         int r;
 118
 119         assert(bus);
 120         assert(message);
 121         assert(m);
 122
 123         r = sd_bus_message_new_method_return(message, &reply);
 124         if (r < 0)
 125                 return sd_bus_error_set_errno(error, r);
 126
 127         r = sd_bus_message_open_container(reply, 'a', "(ssso)");
 128         if (r < 0)
 129                 return sd_bus_error_set_errno(error, r);
 130
 131         HASHMAP_FOREACH(machine, m->machines, i) {
 132                 _cleanup_free_ char *p = NULL;
 133
 134                 p = machine_bus_path(machine);
 135                 if (!p)
 136                         return -ENOMEM;
 137
 138                 r = sd_bus_message_append(reply, "(ssso)",
 139                                           machine->name,
 140                                           strempty(machine_class_to_string(machine->class)),
 141                                           machine->service,
 142                                           p);
 143                 if (r < 0)
 144                         return sd_bus_error_set_errno(error, r);
 145         }
 146
 147         r = sd_bus_message_close_container(reply);
 148         if (r < 0)
 149                 return sd_bus_error_set_errno(error, r);
 150
 151         return sd_bus_send(bus, reply, NULL);
 152 }
 153
 154 static int method_create_or_register_machine(Manager *manager, sd_bus_message *message, bool read_network, Machine **_m, sd_bus_error *error) {
 155         const char *name, *service, *class, *root_directory;
 156         const int32_t *netif = NULL;
 157         MachineClass c;
 158         uint32_t leader;
 159         sd_id128_t id;
 160         const void *v;
 161         Machine *m;
 162         size_t n, n_netif = 0;
 163         int r;
 164
 165         assert(manager);
 166         assert(message);
 167         assert(_m);
 168
 169         r = sd_bus_message_read(message, "s", &name);
 170         if (r < 0)
 171                 return r;
 172         if (!machine_name_is_valid(name))
 173                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid machine name");
 174
 175         r = sd_bus_message_read_array(message, 'y', &v, &n);
 176         if (r < 0)
 177                 return r;
 178         if (n == 0)
 179                 id = SD_ID128_NULL;
 180         else if (n == 16)
 181                 memcpy(&id, v, n);
 182         else
 183                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid machine ID parameter");
 184
 185         r = sd_bus_message_read(message, "ssus", &service, &class, &leader, &root_directory);
 186         if (r < 0)
 187                 return r;
 188
 189         if (read_network) {
 190                 size_t i;
 191
 192                 r = sd_bus_message_read_array(message, 'i', (const void**) &netif, &n_netif);
 193                 if (r < 0)
 194                         return r;
 195
 196                 n_netif /= sizeof(int32_t);
 197
 198                 for (i = 0; i < n_netif; i++) {
 199                         if (netif[i] <= 0)
 200                                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid network interface index %i", netif[i]);
 201                 }
 202         }
 203
 204         if (isempty(class))
 205                 c = _MACHINE_CLASS_INVALID;
 206         else {
 207                 c = machine_class_from_string(class);
 208                 if (c < 0)
 209                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid machine class parameter");
 210         }
 211
 212         if (leader == 1)
 213                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid leader PID");
 214
 215         if (!isempty(root_directory) && !path_is_absolute(root_directory))
 216                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Root directory must be empty or an absolute path");
 217
 218         if (leader == 0) {
 219                 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
 220
 221                 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
 222                 if (r < 0)
 223                         return r;
 224
 225                 assert_cc(sizeof(uint32_t) == sizeof(pid_t));
 226
 227                 r = sd_bus_creds_get_pid(creds, (pid_t*) &leader);
 228                 if (r < 0)
 229                         return r;
 230         }
 231
 232         if (hashmap_get(manager->machines, name))
 233                 return sd_bus_error_setf(error, BUS_ERROR_MACHINE_EXISTS, "Machine '%s' already exists", name);
 234
 235         r = manager_add_machine(manager, name, &m);
 236         if (r < 0)
 237                 return r;
 238
 239         m->leader = leader;
 240         m->class = c;
 241         m->id = id;
 242
 243         if (!isempty(service)) {
 244                 m->service = strdup(service);
 245                 if (!m->service) {
 246                         r = -ENOMEM;
 247                         goto fail;
 248                 }
 249         }
 250
 251         if (!isempty(root_directory)) {
 252                 m->root_directory = strdup(root_directory);
 253                 if (!m->root_directory) {
 254                         r = -ENOMEM;
 255                         goto fail;
 256                 }
 257         }
 258
 259         if (n_netif > 0) {
 260                 assert_cc(sizeof(int32_t) == sizeof(int));
 261                 m->netif = memdup(netif, sizeof(int32_t) * n_netif);
 262                 if (!m->netif) {
 263                         r = -ENOMEM;
 264                         goto fail;
 265                 }
 266
 267                 m->n_netif = n_netif;
 268         }
 269
 270         *_m = m;
 271
 272         return 1;
 273
 274 fail:
 275         machine_add_to_gc_queue(m);
 276         return r;
 277 }
 278
 279 static int method_create_machine_internal(sd_bus *bus, sd_bus_message *message, bool read_network, void *userdata, sd_bus_error *error) {
 280         Manager *manager = userdata;
 281         Machine *m = NULL;
 282         int r;
 283
 284         r = method_create_or_register_machine(manager, message, read_network, &m, error);
 285         if (r < 0)
 286                 return r;
 287
 288         r = sd_bus_message_enter_container(message, 'a', "(sv)");
 289         if (r < 0)
 290                 goto fail;
 291
 292         r = machine_start(m, message, error);
 293         if (r < 0)
 294                 goto fail;
 295
 296         m->create_message = sd_bus_message_ref(message);
 297         return 1;
 298
 299 fail:
 300         machine_add_to_gc_queue(m);
 301         return r;
 302 }
 303
 304 static int method_create_machine_with_network(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
 305         return method_create_machine_internal(bus, message, true, userdata, error);
 306 }
 307
 308 static int method_create_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
 309         return method_create_machine_internal(bus, message, false, userdata, error);
 310 }
 311
 312 static int method_register_machine_internal(sd_bus *bus, sd_bus_message *message, bool read_network, void *userdata, sd_bus_error *error) {
 313         Manager *manager = userdata;
 314         _cleanup_free_ char *p = NULL;
 315         Machine *m = NULL;
 316         int r;
 317
 318         r = method_create_or_register_machine(manager, message, read_network, &m, error);
 319         if (r < 0)
 320                 return r;
 321
 322         r = cg_pid_get_unit(m->leader, &m->unit);
 323         if (r < 0) {
 324                 r = sd_bus_error_set_errnof(error, r, "Failed to determine unit of process "PID_FMT" : %s", m->leader, strerror(-r));
 325                 goto fail;
 326         }
 327
 328         m->registered = true;
 329
 330         r = machine_start(m, NULL, error);
 331         if (r < 0)
 332                 goto fail;
 333
 334         p = machine_bus_path(m);
 335         if (!p) {
 336                 r = -ENOMEM;
 337                 goto fail;
 338         }
 339
 340         return sd_bus_reply_method_return(message, "o", p);
 341
 342 fail:
 343         machine_add_to_gc_queue(m);
 344         return r;
 345 }
 346
 347 static int method_register_machine_with_network(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
 348         return method_register_machine_internal(bus, message, true, userdata, error);
 349 }
 350
 351 static int method_register_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
 352         return method_register_machine_internal(bus, message, false, userdata, error);
 353 }
 354
 355 static int method_terminate_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
 356         Manager *m = userdata;
 357         Machine *machine;
 358         const char *name;
 359         int r;
 360
 361         assert(bus);
 362         assert(message);
 363         assert(m);
 364
 365         r = sd_bus_message_read(message, "s", &name);
 366         if (r < 0)
 367                 return sd_bus_error_set_errno(error, r);
 368
 369         machine = hashmap_get(m->machines, name);
 370         if (!machine)
 371                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
 372
 373         return bus_machine_method_terminate(bus, message, machine, error);
 374 }
 375
 376 static int method_kill_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
 377         Manager *m = userdata;
 378         Machine *machine;
 379         const char *name;
 380         int r;
 381
 382         assert(bus);
 383         assert(message);
 384         assert(m);
 385
 386         r = sd_bus_message_read(message, "s", &name);
 387         if (r < 0)
 388                 return sd_bus_error_set_errno(error, r);
 389
 390         machine = hashmap_get(m->machines, name);
 391         if (!machine)
 392                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
 393
 394         return bus_machine_method_kill(bus, message, machine, error);
 395 }
 396
 397 static int method_get_machine_addresses(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
 398         Manager *m = userdata;
 399         Machine *machine;
 400         const char *name;
 401         int r;
 402
 403         assert(bus);
 404         assert(message);
 405         assert(m);
 406
 407         r = sd_bus_message_read(message, "s", &name);
 408         if (r < 0)
 409                 return sd_bus_error_set_errno(error, r);
 410
 411         machine = hashmap_get(m->machines, name);
 412         if (!machine)
 413                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
 414
 415         return bus_machine_method_get_addresses(bus, message, machine, error);
 416 }
 417
 418 static int method_get_machine_os_release(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
 419         Manager *m = userdata;
 420         Machine *machine;
 421         const char *name;
 422         int r;
 423
 424         assert(bus);
 425         assert(message);
 426         assert(m);
 427
 428         r = sd_bus_message_read(message, "s", &name);
 429         if (r < 0)
 430                 return sd_bus_error_set_errno(error, r);
 431
 432         machine = hashmap_get(m->machines, name);
 433         if (!machine)
 434                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
 435
 436         return bus_machine_method_get_os_release(bus, message, machine, error);
 437 }
 438
 439 const sd_bus_vtable manager_vtable[] = {
 440         SD_BUS_VTABLE_START(0),
 441         SD_BUS_METHOD("GetMachine", "s", "o", method_get_machine, SD_BUS_VTABLE_UNPRIVILEGED),
 442         SD_BUS_METHOD("GetMachineByPID", "u", "o", method_get_machine_by_pid, SD_BUS_VTABLE_UNPRIVILEGED),
 443         SD_BUS_METHOD("ListMachines", NULL, "a(ssso)", method_list_machines, SD_BUS_VTABLE_UNPRIVILEGED),
 444         SD_BUS_METHOD("CreateMachine", "sayssusa(sv)", "o", method_create_machine, 0),
 445         SD_BUS_METHOD("RegisterMachine", "sayssus", "o", method_register_machine, 0),
 446         SD_BUS_METHOD("CreateMachineWithNetwork", "sayssusaia(sv)", "o", method_create_machine_with_network, 0),
 447         SD_BUS_METHOD("RegisterMachineWithNetwork", "sayssusai", "o", method_register_machine_with_network, 0),
 448         SD_BUS_METHOD("KillMachine", "ssi", NULL, method_kill_machine, SD_BUS_VTABLE_CAPABILITY(CAP_KILL)),
 449         SD_BUS_METHOD("TerminateMachine", "s", NULL, method_terminate_machine, SD_BUS_VTABLE_CAPABILITY(CAP_KILL)),
 450         SD_BUS_METHOD("GetMachineAddresses", "s", "a(iay)", method_get_machine_addresses, SD_BUS_VTABLE_UNPRIVILEGED),
 451         SD_BUS_METHOD("GetMachineOSRelease", "s", "a{ss}", method_get_machine_os_release, SD_BUS_VTABLE_UNPRIVILEGED),
 452         SD_BUS_SIGNAL("MachineNew", "so", 0),
 453         SD_BUS_SIGNAL("MachineRemoved", "so", 0),
 454         SD_BUS_VTABLE_END
 455 };
 456
 457 int match_job_removed(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
 458         const char *path, *result, *unit;
 459         Manager *m = userdata;
 460         Machine *machine;
 461         uint32_t id;
 462         int r;
 463
 464         assert(bus);
 465         assert(message);
 466         assert(m);
 467
 468         r = sd_bus_message_read(message, "uoss", &id, &path, &unit, &result);
 469         if (r < 0) {
 470                 bus_log_parse_error(r);
 471                 return r;
 472         }
 473
 474         machine = hashmap_get(m->machine_units, unit);
 475         if (!machine)
 476                 return 0;
 477
 478         if (streq_ptr(path, machine->scope_job)) {
 479                 free(machine->scope_job);
 480                 machine->scope_job = NULL;
 481
 482                 if (machine->started) {
 483                         if (streq(result, "done"))
 484                                 machine_send_create_reply(machine, NULL);
 485                         else {
 486                                 _cleanup_bus_error_free_ sd_bus_error e = SD_BUS_ERROR_NULL;
 487
 488                                 sd_bus_error_setf(&e, BUS_ERROR_JOB_FAILED, "Start job for unit %s failed with '%s'", unit, result);
 489
 490                                 machine_send_create_reply(machine, &e);
 491                         }
 492                 } else
 493                         machine_save(machine);
 494         }
 495
 496         machine_add_to_gc_queue(machine);
 497         return 0;
 498 }
 499
 500 int match_properties_changed(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
 501         _cleanup_free_ char *unit = NULL;
 502         Manager *m = userdata;
 503         Machine *machine;
 504         const char *path;
 505         int r;
 506
 507         assert(bus);
 508         assert(message);
 509         assert(m);
 510
 511         path = sd_bus_message_get_path(message);
 512         if (!path)
 513                 return 0;
 514
 515         r = unit_name_from_dbus_path(path, &unit);
 516         if (r < 0)
 517                 return r;
 518
 519         machine = hashmap_get(m->machine_units, unit);
 520         if (machine)
 521                 machine_add_to_gc_queue(machine);
 522
 523         return 0;
 524 }
 525
 526 int match_unit_removed(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
 527         const char *path, *unit;
 528         Manager *m = userdata;
 529         Machine *machine;
 530         int r;
 531
 532         assert(bus);
 533         assert(message);
 534         assert(m);
 535
 536         r = sd_bus_message_read(message, "so", &unit, &path);
 537         if (r < 0) {
 538                 bus_log_parse_error(r);
 539                 return r;
 540         }
 541
 542         machine = hashmap_get(m->machine_units, unit);
 543         if (machine)
 544                 machine_add_to_gc_queue(machine);
 545
 546         return 0;
 547 }
 548
 549 int match_reloading(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
 550         Manager *m = userdata;
 551         Machine *machine;
 552         Iterator i;
 553         int b, r;
 554
 555         assert(bus);
 556
 557         r = sd_bus_message_read(message, "b", &b);
 558         if (r < 0) {
 559                 bus_log_parse_error(r);
 560                 return r;
 561         }
 562         if (b)
 563                 return 0;
 564
 565         /* systemd finished reloading, let's recheck all our machines */
 566         log_debug("System manager has been reloaded, rechecking machines...");
 567
 568         HASHMAP_FOREACH(machine, m->machines, i)
 569                 machine_add_to_gc_queue(machine);
 570
 571         return 0;
 572 }
 573
 574 int manager_start_scope(
 575                 Manager *manager,
 576                 const char *scope,
 577                 pid_t pid,
 578                 const char *slice,
 579                 const char *description,
 580                 sd_bus_message *more_properties,
 581                 sd_bus_error *error,
 582                 char **job) {
 583
 584         _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
 585         int r;
 586
 587         assert(manager);
 588         assert(scope);
 589         assert(pid > 1);
 590
 591         r = sd_bus_message_new_method_call(
 592                         manager->bus,
 593                         &m,
 594                         "org.freedesktop.systemd1",
 595                         "/org/freedesktop/systemd1",
 596                         "org.freedesktop.systemd1.Manager",
 597                         "StartTransientUnit");
 598         if (r < 0)
 599                 return r;
 600
 601         r = sd_bus_message_append(m, "ss", strempty(scope), "fail");
 602         if (r < 0)
 603                 return r;
 604
 605         r = sd_bus_message_open_container(m, 'a', "(sv)");
 606         if (r < 0)
 607                 return r;
 608
 609         if (!isempty(slice)) {
 610                 r = sd_bus_message_append(m, "(sv)", "Slice", "s", slice);
 611                 if (r < 0)
 612                         return r;
 613         }
 614
 615         if (!isempty(description)) {
 616                 r = sd_bus_message_append(m, "(sv)", "Description", "s", description);
 617                 if (r < 0)
 618                         return r;
 619         }
 620
 621         r = sd_bus_message_append(m, "(sv)", "PIDs", "au", 1, pid);
 622         if (r < 0)
 623                 return r;
 624
 625         if (more_properties) {
 626                 r = sd_bus_message_copy(m, more_properties, true);
 627                 if (r < 0)
 628                         return r;
 629         }
 630
 631         r = sd_bus_message_close_container(m);
 632         if (r < 0)
 633                 return r;
 634
 635         r = sd_bus_message_append(m, "a(sa(sv))", 0);
 636         if (r < 0)
 637                 return r;
 638
 639         r = sd_bus_call(manager->bus, m, 0, error, &reply);
 640         if (r < 0)
 641                 return r;
 642
 643         if (job) {
 644                 const char *j;
 645                 char *copy;
 646
 647                 r = sd_bus_message_read(reply, "o", &j);
 648                 if (r < 0)
 649                         return r;
 650
 651                 copy = strdup(j);
 652                 if (!copy)
 653                         return -ENOMEM;
 654
 655                 *job = copy;
 656         }
 657
 658         return 1;
 659 }
 660
 661 int manager_stop_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job) {
 662         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
 663         int r;
 664
 665         assert(manager);
 666         assert(unit);
 667
 668         r = sd_bus_call_method(
 669                         manager->bus,
 670                         "org.freedesktop.systemd1",
 671                         "/org/freedesktop/systemd1",
 672                         "org.freedesktop.systemd1.Manager",
 673                         "StopUnit",
 674                         error,
 675                         &reply,
 676                         "ss", unit, "fail");
 677         if (r < 0) {
 678                 if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT) ||
 679                     sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED)) {
 680
 681                         if (job)
 682                                 *job = NULL;
 683
 684                         sd_bus_error_free(error);
 685                         return 0;
 686                 }
 687
 688                 return r;
 689         }
 690
 691         if (job) {
 692                 const char *j;
 693                 char *copy;
 694
 695                 r = sd_bus_message_read(reply, "o", &j);
 696                 if (r < 0)
 697                         return r;
 698
 699                 copy = strdup(j);
 700                 if (!copy)
 701                         return -ENOMEM;
 702
 703                 *job = copy;
 704         }
 705
 706         return 1;
 707 }
 708
 709 int manager_kill_unit(Manager *manager, const char *unit, int signo, sd_bus_error *error) {
 710         assert(manager);
 711         assert(unit);
 712
 713         return sd_bus_call_method(
 714                         manager->bus,
 715                         "org.freedesktop.systemd1",
 716                         "/org/freedesktop/systemd1",
 717                         "org.freedesktop.systemd1.Manager",
 718                         "KillUnit",
 719                         error,
 720                         NULL,
 721                         "ssi", unit, "all", signo);
 722 }
 723
 724 int manager_unit_is_active(Manager *manager, const char *unit) {
 725         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 726         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
 727         _cleanup_free_ char *path = NULL;
 728         const char *state;
 729         int r;
 730
 731         assert(manager);
 732         assert(unit);
 733
 734         path = unit_dbus_path_from_name(unit);
 735         if (!path)
 736                 return -ENOMEM;
 737
 738         r = sd_bus_get_property(
 739                         manager->bus,
 740                         "org.freedesktop.systemd1",
 741                         path,
 742                         "org.freedesktop.systemd1.Unit",
 743                         "ActiveState",
 744                         &error,
 745                         &reply,
 746                         "s");
 747         if (r < 0) {
 748                 if (sd_bus_error_has_name(&error, SD_BUS_ERROR_NO_REPLY) ||
 749                     sd_bus_error_has_name(&error, SD_BUS_ERROR_DISCONNECTED))
 750                         return true;
 751
 752                 if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_UNIT) ||
 753                     sd_bus_error_has_name(&error, BUS_ERROR_LOAD_FAILED))
 754                         return false;
 755
 756                 return r;
 757         }
 758
 759         r = sd_bus_message_read(reply, "s", &state);
 760         if (r < 0)
 761                 return -EINVAL;
 762
 763         return !streq(state, "inactive") && !streq(state, "failed");
 764 }
 765
 766 int manager_job_is_active(Manager *manager, const char *path) {
 767         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 768         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
 769         int r;
 770
 771         assert(manager);
 772         assert(path);
 773
 774         r = sd_bus_get_property(
 775                         manager->bus,
 776                         "org.freedesktop.systemd1",
 777                         path,
 778                         "org.freedesktop.systemd1.Job",
 779                         "State",
 780                         &error,
 781                         &reply,
 782                         "s");
 783         if (r < 0) {
 784                 if (sd_bus_error_has_name(&error, SD_BUS_ERROR_NO_REPLY) ||
 785                     sd_bus_error_has_name(&error, SD_BUS_ERROR_DISCONNECTED))
 786                         return true;
 787
 788                 if (sd_bus_error_has_name(&error, SD_BUS_ERROR_UNKNOWN_OBJECT))
 789                         return false;
 790
 791                 return r;
 792         }
 793
 794         /* We don't actually care about the state really. The fact
 795          * that we could read the job state is enough for us */
 796
 797         return true;
 798 }
 799
 800 int manager_get_machine_by_pid(Manager *m, pid_t pid, Machine **machine) {
 801         _cleanup_free_ char *unit = NULL;
 802         Machine *mm;
 803         int r;
 804
 805         assert(m);
 806         assert(pid >= 1);
 807         assert(machine);
 808
 809         r = cg_pid_get_unit(pid, &unit);
 810         if (r < 0)
 811                 mm = hashmap_get(m->machine_leaders, UINT_TO_PTR(pid));
 812         else
 813                 mm = hashmap_get(m->machine_units, unit);
 814
 815         if (!mm)
 816                 return 0;
 817
 818         *machine = mm;
 819         return 1;
 820 }
 821
 822 int manager_add_machine(Manager *m, const char *name, Machine **_machine) {
 823         Machine *machine;
 824
 825         assert(m);
 826         assert(name);
 827
 828         machine = hashmap_get(m->machines, name);
 829         if (!machine) {
 830                 machine = machine_new(m, name);
 831                 if (!machine)
 832                         return -ENOMEM;
 833         }
 834
 835         if (_machine)
 836                 *_machine = machine;
 837
 838         return 0;
 839 }