../src/login/logind-dbus.c

Bug Summary

File:	build-scan/../src/login/logind-dbus.c
Warning:	line 946, column 13 Access to field 'seat' results in a dereference of an undefined pointer value (loaded from variable 'session')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name logind-dbus.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -menable-no-infs -menable-no-nans -menable-unsafe-fp-math -fno-signed-zeros -mreassociate -freciprocal-math -fdenormal-fp-math=preserve-sign,preserve-sign -ffp-contract=fast -fno-rounding-math -ffast-math -ffinite-math-only -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/12.0.0 -include config.h -I src/login/liblogind-core.a.p -I src/login -I ../src/login -I src/basic -I ../src/basic -I src/shared -I ../src/shared -I src/systemd -I ../src/systemd -I src/journal -I ../src/journal -I src/journal-remote -I ../src/journal-remote -I src/nspawn -I ../src/nspawn -I src/resolve -I ../src/resolve -I src/timesync -I ../src/timesync -I ../src/time-wait-sync -I src/udev -I ../src/udev -I src/libudev -I ../src/libudev -I src/core -I ../src/core -I ../src/libsystemd/sd-bus -I ../src/libsystemd/sd-device -I ../src/libsystemd/sd-hwdb -I ../src/libsystemd/sd-id128 -I ../src/libsystemd/sd-netlink -I ../src/libsystemd/sd-network -I src/libsystemd-network -I ../src/libsystemd-network -I . -I .. -D _FILE_OFFSET_BITS=64 -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/12.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wwrite-strings -Wno-unused-parameter -Wno-missing-field-initializers -Wno-unused-result -Wno-format-signedness -Wno-error=nonnull -std=gnu99 -fconst-strings -fdebug-compilation-dir /home/mrc0mmand/repos/@redhat-plumbers/systemd-rhel8/build-scan -ferror-limit 19 -fvisibility hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -analyzer-output=html -faddrsig -o /tmp/scan-build-2021-07-16-221226-1465241-1 -x c ../src/login/logind-dbus.c
1/* SPDX-License-Identifier: LGPL-2.1+ */

3#include <errno(*__errno_location ()).h>
4#include <pwd.h>
5#include <string.h>
6#include <unistd.h>

8#include "sd-messages.h"

10#include "alloc-util.h"
11#include "audit-util.h"
12#include "bus-common-errors.h"
13#include "bus-error.h"
14#include "bus-unit-util.h"
15#include "bus-util.h"
16#include "dirent-util.h"
17#include "efivars.h"
18#include "escape.h"
19#include "fd-util.h"
20#include "fileio-label.h"
21#include "format-util.h"
22#include "fs-util.h"
23#include "logind.h"
24#include "mkdir.h"
25#include "path-util.h"
26#include "process-util.h"
27#include "cgroup-util.h"
28#include "selinux-util.h"
29#include "sleep-config.h"
30#include "special.h"
31#include "strv.h"
32#include "terminal-util.h"
33#include "udev-util.h"
34#include "unit-name.h"
35#include "user-util.h"
36#include "utmp-wtmp.h"

38static int get_sender_session(Manager *m, sd_bus_message *message, sd_bus_error *error, Session **ret) {

      _cleanup_(sd_bus_creds_unrefp)__attribute__((cleanup(sd_bus_creds_unrefp))) sd_bus_creds *creds = NULL((void*)0);
      const char *name;
      Session *session;
      int r;

      /* Get client login session.  This is not what you are looking for these days,
       * as apps may instead belong to a user service unit.  This includes terminal
       * emulators and hence command-line apps. */
      r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_SESSION|SD_BUS_CREDS_AUGMENT, &creds);
      if (r < 0)
              return r;

      r = sd_bus_creds_get_session(creds, &name);
      if (r == -ENXIO6)
              goto err_no_session;
      if (r < 0)
              return r;

      session = hashmap_get(m->sessions, name);
      if (!session)
              goto err_no_session;

      *ret = session;
      return 0;

65err_no_session:
      return sd_bus_error_setf(error, BUS_ERROR_NO_SESSION_FOR_PID"org.freedesktop.login1.NoSessionForPID",
                               "Caller does not belong to any known session");
68}

70int manager_get_session_from_creds(Manager *m, sd_bus_message *message, const char *name, sd_bus_error *error, Session **ret) {
      Session *session;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 73, __PRETTY_FUNCTION__
); } while (0);
11
←
Taking false branch→
12
←
Loop condition is false.  Exiting loop→
      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 74, __PRETTY_FUNCTION__); } while (0);
13
←
Taking false branch→
14
←
Loop condition is false.  Exiting loop→
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/login/logind-dbus.c", 75
, __PRETTY_FUNCTION__); } while (0);
15
←
Taking false branch→
16
←
Loop condition is false.  Exiting loop→

      if (isempty(name))
17
←
Taking false branch→
              return get_sender_session(m, message, error, ret);

      session = hashmap_get(m->sessions, name);
      if (!session)
18
←
Assuming 'session' is null→
19
←
Taking true branch→
              return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SESSION"org.freedesktop.login1.NoSuchSession", "No session '%s' known", name);
20
←
Returning without writing to '*ret'→

      *ret = session;
      return 0;
86}

88static int get_sender_user(Manager *m, sd_bus_message *message, sd_bus_error *error, User **ret) {

      _cleanup_(sd_bus_creds_unrefp)__attribute__((cleanup(sd_bus_creds_unrefp))) sd_bus_creds *creds = NULL((void*)0);
      uid_t uid;
      User *user;
      int r;

      /* Note that we get the owner UID of the session, not the actual client UID here! */
      r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_OWNER_UID|SD_BUS_CREDS_AUGMENT, &creds);
      if (r < 0)
              return r;

      r = sd_bus_creds_get_owner_uid(creds, &uid);
      if (r == -ENXIO6)
              goto err_no_user;
      if (r < 0)
              return r;

      user = hashmap_get(m->users, UID_TO_PTR(uid)((void*) (((uintptr_t) (uid))+1)));
      if (!user)
              goto err_no_user;

      *ret = user;
      return 0;

113err_no_user:
      return sd_bus_error_setf(error, BUS_ERROR_NO_USER_FOR_PID"org.freedesktop.login1.NoUserForPID", "Caller does not belong to any logged in user or lingering user");
115}

117int manager_get_user_from_creds(Manager *m, sd_bus_message *message, uid_t uid, sd_bus_error *error, User **ret) {
      User *user;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 120,
 __PRETTY_FUNCTION__); } while (0);
      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 121, __PRETTY_FUNCTION__); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/login/logind-dbus.c", 122
, __PRETTY_FUNCTION__); } while (0);

      if (!uid_is_valid(uid))
              return get_sender_user(m, message, error, ret);

      user = hashmap_get(m->users, UID_TO_PTR(uid)((void*) (((uintptr_t) (uid))+1)));
      if (!user)
              return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_USER"org.freedesktop.login1.NoSuchUser", "User ID "UID_FMT"%" "u"" is not logged in or lingering", uid);

      *ret = user;
      return 0;
133}

135int manager_get_seat_from_creds(Manager *m, sd_bus_message *message, const char *name, sd_bus_error *error, Seat **ret) {
      Seat *seat;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 139,
 __PRETTY_FUNCTION__); } while (0);
      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 140, __PRETTY_FUNCTION__); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/login/logind-dbus.c", 141
, __PRETTY_FUNCTION__); } while (0);

      if (isempty(name)) {
              Session *session;

              r = manager_get_session_from_creds(m, message, NULL((void*)0), error, &session);
              if (r < 0)
                      return r;

              seat = session->seat;
              if (!seat)
                      return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SEAT"org.freedesktop.login1.NoSuchSeat", "Session has no seat.");
      } else {
              seat = hashmap_get(m->seats, name);
              if (!seat)
                      return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SEAT"org.freedesktop.login1.NoSuchSeat", "No seat '%s' known", name);
      }

      *ret = seat;
      return 0;
161}

163static int property_get_idle_hint(
              sd_bus *bus,
              const char *path,
              const char *interface,
              const char *property,
              sd_bus_message *reply,
              void *userdata,
              sd_bus_error *error) {

      Manager *m = userdata;

      assert(bus)do { if ((__builtin_expect(!!(!(bus)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/login/logind-dbus.c", 174
, __PRETTY_FUNCTION__); } while (0);
      assert(reply)do { if ((__builtin_expect(!!(!(reply)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("reply"), "../src/login/logind-dbus.c", 175
, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 176,
 __PRETTY_FUNCTION__); } while (0);

      return sd_bus_message_append(reply, "b", manager_get_idle_hint(m, NULL((void*)0)) > 0);
179}

181static int property_get_idle_since_hint(
              sd_bus *bus,
              const char *path,
              const char *interface,
              const char *property,
              sd_bus_message *reply,
              void *userdata,
              sd_bus_error *error) {

      Manager *m = userdata;
      dual_timestamp t = DUAL_TIMESTAMP_NULL((struct dual_timestamp) {});

      assert(bus)do { if ((__builtin_expect(!!(!(bus)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/login/logind-dbus.c", 193
, __PRETTY_FUNCTION__); } while (0);
      assert(reply)do { if ((__builtin_expect(!!(!(reply)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("reply"), "../src/login/logind-dbus.c", 194
, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 195,
 __PRETTY_FUNCTION__); } while (0);

      manager_get_idle_hint(m, &t);

      return sd_bus_message_append(reply, "t", streq(property, "IdleSinceHint")(strcmp((property),("IdleSinceHint")) == 0) ? t.realtime : t.monotonic);
200}

202static int property_get_inhibited(
              sd_bus *bus,
              const char *path,
              const char *interface,
              const char *property,
              sd_bus_message *reply,
              void *userdata,
              sd_bus_error *error) {

      Manager *m = userdata;
      InhibitWhat w;

      assert(bus)do { if ((__builtin_expect(!!(!(bus)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/login/logind-dbus.c", 214
, __PRETTY_FUNCTION__); } while (0);
      assert(reply)do { if ((__builtin_expect(!!(!(reply)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("reply"), "../src/login/logind-dbus.c", 215
, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 216,
 __PRETTY_FUNCTION__); } while (0);

      w = manager_inhibit_what(m, streq(property, "BlockInhibited")(strcmp((property),("BlockInhibited")) == 0) ? INHIBIT_BLOCK : INHIBIT_DELAY);

      return sd_bus_message_append(reply, "s", inhibit_what_to_string(w));
221}

223static int property_get_preparing(
              sd_bus *bus,
              const char *path,
              const char *interface,
              const char *property,
              sd_bus_message *reply,
              void *userdata,
              sd_bus_error *error) {

      Manager *m = userdata;
      bool_Bool b;

      assert(bus)do { if ((__builtin_expect(!!(!(bus)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/login/logind-dbus.c", 235
, __PRETTY_FUNCTION__); } while (0);
      assert(reply)do { if ((__builtin_expect(!!(!(reply)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("reply"), "../src/login/logind-dbus.c", 236
, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 237,
 __PRETTY_FUNCTION__); } while (0);

      if (streq(property, "PreparingForShutdown")(strcmp((property),("PreparingForShutdown")) == 0))
              b = m->action_what & INHIBIT_SHUTDOWN;
      else
              b = m->action_what & INHIBIT_SLEEP;

      return sd_bus_message_append(reply, "b", b);
245}

247static int property_get_scheduled_shutdown(
              sd_bus *bus,
              const char *path,
              const char *interface,
              const char *property,
              sd_bus_message *reply,
              void *userdata,
              sd_bus_error *error) {

      Manager *m = userdata;
      int r;

      assert(bus)do { if ((__builtin_expect(!!(!(bus)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/login/logind-dbus.c", 259
, __PRETTY_FUNCTION__); } while (0);
      assert(reply)do { if ((__builtin_expect(!!(!(reply)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("reply"), "../src/login/logind-dbus.c", 260
, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 261,
 __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_open_container(reply, 'r', "st");
      if (r < 0)
              return r;

      r = sd_bus_message_append(reply, "st", m->scheduled_shutdown_type, m->scheduled_shutdown_timeout);
      if (r < 0)
              return r;

      return sd_bus_message_close_container(reply);
272}

274static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_handle_action, handle_action, HandleAction)int property_get_handle_action(sd_bus *bus, const char *path,
 const char *interface, const char *property, sd_bus_message *
reply, void *userdata, sd_bus_error *error) { HandleAction *data
 = userdata; do { if ((__builtin_expect(!!(!(bus)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/login/logind-dbus.c", 274
, __PRETTY_FUNCTION__); } while (0); do { if ((__builtin_expect
(!!(!(reply)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD,
 ("reply"), "../src/login/logind-dbus.c", 274, __PRETTY_FUNCTION__
); } while (0); do { if ((__builtin_expect(!!(!(data)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("data"), "../src/login/logind-dbus.c", 274
, __PRETTY_FUNCTION__); } while (0); return sd_bus_message_append
(reply, "s", handle_action_to_string((*(data)))); };
275static BUS_DEFINE_PROPERTY_GET(property_get_docked, "b", Manager, manager_is_docked_or_external_displays)int property_get_docked(sd_bus *bus, const char *path, const char
 *interface, const char *property, sd_bus_message *reply, void
 *userdata, sd_bus_error *error) { Manager *data = userdata; do
 { if ((__builtin_expect(!!(!(bus)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/login/logind-dbus.c", 275
, __PRETTY_FUNCTION__); } while (0); do { if ((__builtin_expect
(!!(!(reply)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD,
 ("reply"), "../src/login/logind-dbus.c", 275, __PRETTY_FUNCTION__
); } while (0); do { if ((__builtin_expect(!!(!(data)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("data"), "../src/login/logind-dbus.c", 275
, __PRETTY_FUNCTION__); } while (0); return sd_bus_message_append
(reply, "b", (manager_is_docked_or_external_displays(data)));
 };
276static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_compat_user_tasks_max, "t", CGROUP_LIMIT_MAX)int property_get_compat_user_tasks_max(sd_bus *bus, const char
 *path, const char *interface, const char *property, sd_bus_message
 *reply, void *userdata, sd_bus_error *error) { do { if ((__builtin_expect
(!!(!(bus)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, (
"bus"), "../src/login/logind-dbus.c", 276, __PRETTY_FUNCTION__
); } while (0); do { if ((__builtin_expect(!!(!(reply)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("reply"), "../src/login/logind-dbus.c", 276
, __PRETTY_FUNCTION__); } while (0); return sd_bus_message_append
(reply, "t", ((uint64_t) -1)); };
277static BUS_DEFINE_PROPERTY_GET_REF(property_get_hashmap_size, "t", Hashmap *, (uint64_t) hashmap_size)int property_get_hashmap_size(sd_bus *bus, const char *path, const
 char *interface, const char *property, sd_bus_message *reply
, void *userdata, sd_bus_error *error) { Hashmap * *data = userdata
; do { if ((__builtin_expect(!!(!(bus)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/login/logind-dbus.c", 277
, __PRETTY_FUNCTION__); } while (0); do { if ((__builtin_expect
(!!(!(reply)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD,
 ("reply"), "../src/login/logind-dbus.c", 277, __PRETTY_FUNCTION__
); } while (0); do { if ((__builtin_expect(!!(!(data)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("data"), "../src/login/logind-dbus.c", 277
, __PRETTY_FUNCTION__); } while (0); return sd_bus_message_append
(reply, "t", (uint64_t) hashmap_size((*(data)))); };

279static int method_get_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);
      Manager *m = userdata;
      const char *name;
      Session *session;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 286, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 287,
 __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "s", &name);
      if (r < 0)
              return r;

      r = manager_get_session_from_creds(m, message, name, error, &session);
      if (r < 0)
              return r;

      p = session_bus_path(session);
      if (!p)
              return -ENOMEM12;

      return sd_bus_reply_method_return(message, "o", p);
302}

304/* Get login session of a process.  This is not what you are looking for these days,
* as apps may instead belong to a user service unit.  This includes terminal
* emulators and hence command-line apps. */
307static int method_get_session_by_pid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);
      Session *session = NULL((void*)0);
      Manager *m = userdata;
      pid_t pid;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 314, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 315,
 __PRETTY_FUNCTION__); } while (0);

      assert_cc(sizeof(pid_t) == sizeof(uint32_t))GCC diagnostic push
; GCC diagnostic ignored "-Wdeclaration-after-statement"

; struct _assert_struct_37 { char x[(sizeof(pid_t) == sizeof
(uint32_t)) ? 0 : -1]; }; GCC diagnostic pop
;

      r = sd_bus_message_read(message, "u", &pid);
      if (r < 0)
              return r;
      if (pid < 0)
              return -EINVAL22;

      if (pid == 0) {
              r = manager_get_session_from_creds(m, message, NULL((void*)0), error, &session);
              if (r < 0)
                      return r;
      } else {
              r = manager_get_session_by_pid(m, pid, &session);
              if (r < 0)
                      return r;

              if (!session)
                      return sd_bus_error_setf(error, BUS_ERROR_NO_SESSION_FOR_PID"org.freedesktop.login1.NoSessionForPID", "PID "PID_FMT"%" "i"" does not belong to any known session", pid);
      }

      p = session_bus_path(session);
      if (!p)
              return -ENOMEM12;

      return sd_bus_reply_method_return(message, "o", p);
343}

345static int method_get_user(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);
      Manager *m = userdata;
      uint32_t uid;
      User *user;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 352, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 353,
 __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "u", &uid);
      if (r < 0)
              return r;

      r = manager_get_user_from_creds(m, message, uid, error, &user);
      if (r < 0)
              return r;

      p = user_bus_path(user);
      if (!p)
              return -ENOMEM12;

      return sd_bus_reply_method_return(message, "o", p);
368}

370static int method_get_user_by_pid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);
      Manager *m = userdata;
      User *user = NULL((void*)0);
      pid_t pid;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 377, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 378,
 __PRETTY_FUNCTION__); } while (0);

      assert_cc(sizeof(pid_t) == sizeof(uint32_t))GCC diagnostic push
; GCC diagnostic ignored "-Wdeclaration-after-statement"

; struct _assert_struct_38 { char x[(sizeof(pid_t) == sizeof
(uint32_t)) ? 0 : -1]; }; GCC diagnostic pop
;

      r = sd_bus_message_read(message, "u", &pid);
      if (r < 0)
              return r;
      if (pid < 0)
              return -EINVAL22;

      if (pid == 0) {
              r = manager_get_user_from_creds(m, message, UID_INVALID((uid_t) -1), error, &user);
              if (r < 0)
                      return r;
      } else {
              r = manager_get_user_by_pid(m, pid, &user);
              if (r < 0)
                      return r;
              if (!user)
                      return sd_bus_error_setf(error, BUS_ERROR_NO_USER_FOR_PID"org.freedesktop.login1.NoUserForPID",
                                               "PID "PID_FMT"%" "i"" does not belong to any logged in user or lingering user",
                                               pid);
      }

      p = user_bus_path(user);
      if (!p)
              return -ENOMEM12;

      return sd_bus_reply_method_return(message, "o", p);
407}

409static int method_get_seat(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);
      Manager *m = userdata;
      const char *name;
      Seat *seat;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 416, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 417,
 __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "s", &name);
      if (r < 0)
              return r;

      r = manager_get_seat_from_creds(m, message, name, error, &seat);
      if (r < 0)
              return r;

      p = seat_bus_path(seat);
      if (!p)
              return -ENOMEM12;

      return sd_bus_reply_method_return(message, "o", p);
432}

434static int method_list_sessions(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      _cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *reply = NULL((void*)0);
      Manager *m = userdata;
      Session *session;
      Iterator i;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 441, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 442,
 __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_new_method_return(message, &reply);
      if (r < 0)
              return r;

      r = sd_bus_message_open_container(reply, 'a', "(susso)");
      if (r < 0)
              return r;

      HASHMAP_FOREACH(session, m->sessions, i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((m->sessions), &
(i), (void**)&(session), ((void*)0)); ) {
              _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);

              p = session_bus_path(session);
              if (!p)
                      return -ENOMEM12;

              r = sd_bus_message_append(reply, "(susso)",
                                        session->id,
                                        (uint32_t) session->user->uid,
                                        session->user->name,
                                        session->seat ? session->seat->id : "",
                                        p);
              if (r < 0)
                      return r;
      }

      r = sd_bus_message_close_container(reply);
      if (r < 0)
              return r;

      return sd_bus_send(NULL((void*)0), reply, NULL((void*)0));
474}

476static int method_list_users(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      _cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *reply = NULL((void*)0);
      Manager *m = userdata;
      User *user;
      Iterator i;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 483, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 484,
 __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_new_method_return(message, &reply);
      if (r < 0)
              return r;

      r = sd_bus_message_open_container(reply, 'a', "(uso)");
      if (r < 0)
              return r;

      HASHMAP_FOREACH(user, m->users, i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((m->users), &
(i), (void**)&(user), ((void*)0)); ) {
              _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);

              p = user_bus_path(user);
              if (!p)
                      return -ENOMEM12;

              r = sd_bus_message_append(reply, "(uso)",
                                        (uint32_t) user->uid,
                                        user->name,
                                        p);
              if (r < 0)
                      return r;
      }

      r = sd_bus_message_close_container(reply);
      if (r < 0)
              return r;

      return sd_bus_send(NULL((void*)0), reply, NULL((void*)0));
514}

516static int method_list_seats(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      _cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *reply = NULL((void*)0);
      Manager *m = userdata;
      Seat *seat;
      Iterator i;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 523, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 524,
 __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_new_method_return(message, &reply);
      if (r < 0)
              return r;

      r = sd_bus_message_open_container(reply, 'a', "(so)");
      if (r < 0)
              return r;

      HASHMAP_FOREACH(seat, m->seats, i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((m->seats), &
(i), (void**)&(seat), ((void*)0)); ) {
              _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);

              p = seat_bus_path(seat);
              if (!p)
                      return -ENOMEM12;

              r = sd_bus_message_append(reply, "(so)", seat->id, p);
              if (r < 0)
                      return r;
      }

      r = sd_bus_message_close_container(reply);
      if (r < 0)
              return r;

      return sd_bus_send(NULL((void*)0), reply, NULL((void*)0));
551}

553static int method_list_inhibitors(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      _cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *reply = NULL((void*)0);
      Manager *m = userdata;
      Inhibitor *inhibitor;
      Iterator i;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 560, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 561,
 __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_new_method_return(message, &reply);
      if (r < 0)
              return r;

      r = sd_bus_message_open_container(reply, 'a', "(ssssuu)");
      if (r < 0)
              return r;

      HASHMAP_FOREACH(inhibitor, m->inhibitors, i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((m->inhibitors),
 &(i), (void**)&(inhibitor), ((void*)0)); ) {

              r = sd_bus_message_append(reply, "(ssssuu)",
                                        strempty(inhibit_what_to_string(inhibitor->what)),
                                        strempty(inhibitor->who),
                                        strempty(inhibitor->why),
                                        strempty(inhibit_mode_to_string(inhibitor->mode)),
                                        (uint32_t) inhibitor->uid,
                                        (uint32_t) inhibitor->pid);
              if (r < 0)
                      return r;
      }

      r = sd_bus_message_close_container(reply);
      if (r < 0)
              return r;

      return sd_bus_send(NULL((void*)0), reply, NULL((void*)0));
589}

591static int method_create_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      const char *service, *type, *class, *cseat, *tty, *display, *remote_user, *remote_host, *desktop;
      _cleanup_free___attribute__((cleanup(freep))) char *id = NULL((void*)0);
      Session *session = NULL((void*)0);
      uint32_t audit_id = 0;
      Manager *m = userdata;
      User *user = NULL((void*)0);
      Seat *seat = NULL((void*)0);
      pid_t leader;
      uid_t uid;
      int remote;
      uint32_t vtnr = 0;
      SessionType t;
      SessionClass c;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 607, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 608,
 __PRETTY_FUNCTION__); } while (0);

      assert_cc(sizeof(pid_t) == sizeof(uint32_t))GCC diagnostic push
; GCC diagnostic ignored "-Wdeclaration-after-statement"

; struct _assert_struct_39 { char x[(sizeof(pid_t) == sizeof
(uint32_t)) ? 0 : -1]; }; GCC diagnostic pop
;
      assert_cc(sizeof(uid_t) == sizeof(uint32_t))GCC diagnostic push
; GCC diagnostic ignored "-Wdeclaration-after-statement"

; struct _assert_struct_40 { char x[(sizeof(uid_t) == sizeof
(uint32_t)) ? 0 : -1]; }; GCC diagnostic pop
;

      r = sd_bus_message_read(message, "uusssssussbss", &uid, &leader, &service, &type, &class, &desktop, &cseat, &vtnr, &tty, &display, &remote, &remote_user, &remote_host);
      if (r < 0)
              return r;

      if (!uid_is_valid(uid))
              return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Invalid UID");
      if (leader < 0 || leader == 1 || leader == getpid_cached())
              return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Invalid leader PID");

      if (isempty(type))
              t = _SESSION_TYPE_INVALID;
      else {
              t = session_type_from_string(type);
              if (t < 0)
                      return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Invalid session type %s", type);
      }

      if (isempty(class))
              c = _SESSION_CLASS_INVALID;
      else {
              c = session_class_from_string(class);
              if (c < 0)
                      return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Invalid session class %s", class);
      }

      if (isempty(desktop))
              desktop = NULL((void*)0);
      else {
              if (!string_is_safe(desktop))
                      return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Invalid desktop string %s", desktop);
      }

      if (isempty(cseat))
              seat = NULL((void*)0);
      else {
              seat = hashmap_get(m->seats, cseat);
              if (!seat)
                      return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SEAT"org.freedesktop.login1.NoSuchSeat", "No seat '%s' known", cseat);
      }

      if (tty_is_vc(tty)) {
              int v;

              if (!seat)
                      seat = m->seat0;
              else if (seat != m->seat0)
                      return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "TTY %s is virtual console but seat %s is not seat0", tty, seat->id);

              v = vtnr_from_tty(tty);
              if (v <= 0)
                      return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Cannot determine VT number from virtual console TTY %s", tty);

              if (vtnr == 0)
                      vtnr = (uint32_t) v;
              else if (vtnr != (uint32_t) v)
                      return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Specified TTY and VT number do not match");

      } else if (tty_is_console(tty)) {

              if (!seat)
                      seat = m->seat0;
              else if (seat != m->seat0)
                      return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Console TTY specified but seat is not seat0");

              if (vtnr != 0)
                      return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Console TTY specified but VT number is not 0");
      }

      if (seat) {
              if (seat_has_vts(seat)) {
                      if (vtnr <= 0 || vtnr > 63)
                              return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "VT number out of range");
              } else {
                      if (vtnr != 0)
                              return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Seat has no VTs but VT number not 0");
              }
      }

      if (t == _SESSION_TYPE_INVALID) {
              if (!isempty(display))
                      t = SESSION_X11;
              else if (!isempty(tty))
                      t = SESSION_TTY;
              else
                      t = SESSION_UNSPECIFIED;
      }

      if (c == _SESSION_CLASS_INVALID) {
              if (t == SESSION_UNSPECIFIED)
                      c = SESSION_BACKGROUND;
              else
                      c = SESSION_USER;
      }

      if (leader == 0) {
              _cleanup_(sd_bus_creds_unrefp)__attribute__((cleanup(sd_bus_creds_unrefp))) sd_bus_creds *creds = NULL((void*)0);

              r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
              if (r < 0)
                      return r;

              r = sd_bus_creds_get_pid(creds, (pid_t*) &leader);
              if (r < 0)
                      return r;
      }

      /* Check if we are already in a logind session. Or if we are in user@.service which is a special PAM session
       * that avoids creating a logind session. */
      r = manager_get_user_by_pid(m, leader, NULL((void*)0));
      if (r < 0)
              return r;
      if (r > 0)
              return sd_bus_error_setf(error, BUS_ERROR_SESSION_BUSY"org.freedesktop.login1.SessionBusy", "Already running in a session or user slice");

      /*
       * Old gdm and lightdm start the user-session on the same VT as
       * the greeter session. But they destroy the greeter session
       * after the user-session and want the user-session to take
       * over the VT. We need to support this for
       * backwards-compatibility, so make sure we allow new sessions
       * on a VT that a greeter is running on. Furthermore, to allow
       * re-logins, we have to allow a greeter to take over a used VT for
       * the exact same reasons.
       */
      if (c != SESSION_GREETER &&
          vtnr > 0 &&
          vtnr < m->seat0->position_count &&
          m->seat0->positions[vtnr] &&
          m->seat0->positions[vtnr]->class != SESSION_GREETER)
              return sd_bus_error_setf(error, BUS_ERROR_SESSION_BUSY"org.freedesktop.login1.SessionBusy", "Already occupied by a session");

      if (hashmap_size(m->sessions) >= m->sessions_max)
              return sd_bus_error_setf(error, SD_BUS_ERROR_LIMITS_EXCEEDED"org.freedesktop.DBus.Error.LimitsExceeded", "Maximum number of sessions (%" PRIu64"l" "u" ") reached, refusing further sessions.", m->sessions_max);

      (void) audit_session_from_pid(leader, &audit_id);
      if (audit_session_is_valid(audit_id)) {
              /* Keep our session IDs and the audit session IDs in sync */

              if (asprintf(&id, "%"PRIu32"u", audit_id) < 0)
                      return -ENOMEM12;

              /* Wut? There's already a session by this name and we
               * didn't find it above? Weird, then let's not trust
               * the audit data and let's better register a new
               * ID */
              if (hashmap_get(m->sessions, id)) {
                      log_warning("Existing logind session ID %s used by new audit session, ignoring.", id)({ int _level = (((4))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 759, __func__, "Existing logind session ID %s used by new audit session, ignoring."
, id) : -abs(_e); });
                      audit_id = AUDIT_SESSION_INVALID((uint32_t) -1);
                      id = mfree(id);
              }
      }

      if (!id) {
              do {
                      id = mfree(id);

                      if (asprintf(&id, "c%lu", ++m->session_counter) < 0)
                              return -ENOMEM12;

              } while (hashmap_get(m->sessions, id));
      }

      r = manager_add_user_by_uid(m, uid, &user);
      if (r < 0)
              goto fail;

      r = manager_add_session(m, id, &session);
      if (r < 0)
              goto fail;

      session_set_user(session, user);

      session->leader = leader;
      session->audit_id = audit_id;
      session->type = t;
      session->class = c;
      session->remote = remote;
      session->vtnr = vtnr;

      if (!isempty(tty)) {
              session->tty = strdup(tty);
              if (!session->tty) {
                      r = -ENOMEM12;
                      goto fail;
              }
      }

      if (!isempty(display)) {
              session->display = strdup(display);
              if (!session->display) {
                      r = -ENOMEM12;
                      goto fail;
              }
      }

      if (!isempty(remote_user)) {
              session->remote_user = strdup(remote_user);
              if (!session->remote_user) {
                      r = -ENOMEM12;
                      goto fail;
              }
      }

      if (!isempty(remote_host)) {
              session->remote_host = strdup(remote_host);
              if (!session->remote_host) {
                      r = -ENOMEM12;
                      goto fail;
              }
      }

      if (!isempty(service)) {
              session->service = strdup(service);
              if (!session->service) {
                      r = -ENOMEM12;
                      goto fail;
              }
      }

      if (!isempty(desktop)) {
              session->desktop = strdup(desktop);
              if (!session->desktop) {
                      r = -ENOMEM12;
                      goto fail;
              }
      }

      if (seat) {
              r = seat_attach_session(seat, session);
              if (r < 0)
                      goto fail;
      }

      r = sd_bus_message_enter_container(message, 'a', "(sv)");
      if (r < 0)
              return r;

      r = session_start(session, message);
      if (r < 0)
              goto fail;

      r = sd_bus_message_exit_container(message);
      if (r < 0)
              goto fail;

      session->create_message = sd_bus_message_ref(message);

      /* Now, let's wait until the slice unit and stuff got created. We send the reply back from
       * session_send_create_reply(). */

      return 1;

865fail:
      if (session)
              session_add_to_gc_queue(session);

      if (user)
              user_add_to_gc_queue(user);

      return r;
873}

875static int method_release_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;
      Session *session;
      const char *name;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 881, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 882,
 __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "s", &name);
      if (r < 0)
              return r;

      r = manager_get_session_from_creds(m, message, name, error, &session);
      if (r < 0)
              return r;

      r = session_release(session);
      if (r < 0)
              return r;

      return sd_bus_reply_method_return(message, NULL((void*)0));
897}

899static int method_activate_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;
      Session *session;
      const char *name;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 905, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 906,
 __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "s", &name);
      if (r < 0)
              return r;

      r = manager_get_session_from_creds(m, message, name, error, &session);
      if (r < 0)
              return r;

      /* PolicyKit is done by bus_session_method_activate() */

      return bus_session_method_activate(message, session, error);
919}

921static int method_activate_session_on_seat(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      const char *session_name, *seat_name;
      Manager *m = userdata;
      Session *session;
1
'session' declared without an initial value→
      Seat *seat;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 928, __PRETTY_FUNCTION__); } while (0);
2
←
Assuming 'message' is non-null→
3
←
Taking false branch→
4
←
Loop condition is false.  Exiting loop→
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 929,
 __PRETTY_FUNCTION__); } while (0);
5
←
Assuming 'm' is non-null→
6
←
Taking false branch→
7
←
Loop condition is false.  Exiting loop→

      /* Same as ActivateSession() but refuses to work if
       * the seat doesn't match */

      r = sd_bus_message_read(message, "ss", &session_name, &seat_name);
      if (r < 0)
8
←
Assuming 'r' is >= 0→
9
←
Taking false branch→
              return r;

      r = manager_get_session_from_creds(m, message, session_name, error, &session);
10
←
Calling 'manager_get_session_from_creds'→
21
←
Returning from 'manager_get_session_from_creds'→
      if (r < 0)
22
←
Assuming 'r' is >= 0→
23
←
Taking false branch→
              return r;

      r = manager_get_seat_from_creds(m, message, seat_name, error, &seat);
      if (r23.1
'r' is >= 0
 < 0)
24
←
Taking false branch→
              return r;

      if (session->seat != seat)
25
←
Access to field 'seat' results in a dereference of an undefined pointer value (loaded from variable 'session')
              return sd_bus_error_setf(error, BUS_ERROR_SESSION_NOT_ON_SEAT"org.freedesktop.login1.SessionNotOnSeat", "Session %s not on seat %s", session_name, seat_name);

      r = bus_verify_polkit_async(
                      message,
                      CAP_SYS_ADMIN21,
                      "org.freedesktop.login1.chvt",
                      NULL((void*)0),
                      false0,
                      UID_INVALID((uid_t) -1),
                      &m->polkit_registry,
                      error);
      if (r < 0)
              return r;
      if (r == 0)
              return 1; /* Will call us back */

      r = session_activate(session);
      if (r < 0)
              return r;

      return sd_bus_reply_method_return(message, NULL((void*)0));
968}

970static int method_lock_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;
      Session *session;
      const char *name;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 976, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 977,
 __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "s", &name);
      if (r < 0)
              return r;

      r = manager_get_session_from_creds(m, message, name, error, &session);
      if (r < 0)
              return r;

      return bus_session_method_lock(message, session, error);
988}

990static int method_lock_sessions(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 994, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 995,
 __PRETTY_FUNCTION__); } while (0);

      r = bus_verify_polkit_async(
                      message,
                      CAP_SYS_ADMIN21,
                      "org.freedesktop.login1.lock-sessions",
                      NULL((void*)0),
                      false0,
                      UID_INVALID((uid_t) -1),
                      &m->polkit_registry,
                      error);
      if (r < 0)
              return r;
      if (r == 0)
              return 1; /* Will call us back */

      r = session_send_lock_all(m, streq(sd_bus_message_get_member(message), "LockSessions")(strcmp((sd_bus_message_get_member(message)),("LockSessions")
) == 0));
      if (r < 0)
              return r;

      return sd_bus_reply_method_return(message, NULL((void*)0));
1016}

1018static int method_kill_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      const char *name;
      Manager *m = userdata;
      Session *session;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 1024, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1025
, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "s", &name);
      if (r < 0)
              return r;

      r = manager_get_session_from_creds(m, message, name, error, &session);
      if (r < 0)
              return r;

      return bus_session_method_kill(message, session, error);
1036}

1038static int method_kill_user(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;
      uint32_t uid;
      User *user;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 1044, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1045
, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "u", &uid);
      if (r < 0)
              return r;

      r = manager_get_user_from_creds(m, message, uid, error, &user);
      if (r < 0)
              return r;

      return bus_user_method_kill(message, user, error);
1056}

1058static int method_terminate_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;
      const char *name;
      Session *session;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 1064, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1065
, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "s", &name);
      if (r < 0)
              return r;

      r = manager_get_session_from_creds(m, message, name, error, &session);
      if (r < 0)
              return r;

      return bus_session_method_terminate(message, session, error);
1076}

1078static int method_terminate_user(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;
      uint32_t uid;
      User *user;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 1084, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1085
, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "u", &uid);
      if (r < 0)
              return r;

      r = manager_get_user_from_creds(m, message, uid, error, &user);
      if (r < 0)
              return r;

      return bus_user_method_terminate(message, user, error);
1096}

1098static int method_terminate_seat(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;
      const char *name;
      Seat *seat;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 1104, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1105
, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "s", &name);
      if (r < 0)
              return r;

      r = manager_get_seat_from_creds(m, message, name, error, &seat);
      if (r < 0)
              return r;

      return bus_seat_method_terminate(message, seat, error);
1116}

1118static int method_set_user_linger(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      _cleanup_(sd_bus_creds_unrefp)__attribute__((cleanup(sd_bus_creds_unrefp))) sd_bus_creds *creds = NULL((void*)0);
      _cleanup_free___attribute__((cleanup(freep))) char *cc = NULL((void*)0);
      Manager *m = userdata;
      int r, b, interactive;
      struct passwd *pw;
      const char *path;
      uint32_t uid, auth_uid;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 1127, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1128
, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "ubb", &uid, &b, &interactive);
      if (r < 0)
              return r;

      r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID |
                                             SD_BUS_CREDS_OWNER_UID|SD_BUS_CREDS_AUGMENT, &creds);
      if (r < 0)
              return r;

      if (!uid_is_valid(uid)) {
              /* Note that we get the owner UID of the session or user unit,
               * not the actual client UID here! */
              r = sd_bus_creds_get_owner_uid(creds, &uid);
              if (r < 0)
                      return r;
      }

      /* owner_uid is racy, so for authorization we must use euid */
      r = sd_bus_creds_get_euid(creds, &auth_uid);
      if (r < 0)
              return r;

      errno(*__errno_location ()) = 0;
      pw = getpwuid(uid);
      if (!pw)
              return errno(*__errno_location ()) > 0 ? -errno(*__errno_location ()) : -ENOENT2;

      r = bus_verify_polkit_async(
                      message,
                      CAP_SYS_ADMIN21,
                      uid == auth_uid ? "org.freedesktop.login1.set-self-linger" :
                                        "org.freedesktop.login1.set-user-linger",
                      NULL((void*)0),
                      interactive,
                      UID_INVALID((uid_t) -1),
                      &m->polkit_registry,
                      error);
      if (r < 0)
              return r;
      if (r == 0)
              return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */

      mkdir_p_label("/var/lib/systemd", 0755);

      r = mkdir_safe_label("/var/lib/systemd/linger", 0755, 0, 0, MKDIR_WARN_MODE);
      if (r < 0)
              return r;

      cc = cescape(pw->pw_name);
      if (!cc)
              return -ENOMEM12;

      path = strjoina("/var/lib/systemd/linger/", cc)({ const char *_appendees_[] = { "/var/lib/systemd/linger/", cc
 }; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for (_i_ =
 0; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
 (_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });
      if (b) {
              User *u;

              r = touch(path);
              if (r < 0)
                      return r;

              if (manager_add_user_by_uid(m, uid, &u) >= 0)
                      user_start(u);

      } else {
              User *u;

              r = unlink(path);
              if (r < 0 && errno(*__errno_location ()) != ENOENT2)
                      return -errno(*__errno_location ());

              u = hashmap_get(m->users, UID_TO_PTR(uid)((void*) (((uintptr_t) (uid))+1)));
              if (u)
                      user_add_to_gc_queue(u);
      }

      return sd_bus_reply_method_return(message, NULL((void*)0));
1206}

1208static int trigger_device(Manager *m, struct udev_device *d) {
      _cleanup_(udev_enumerate_unrefp)__attribute__((cleanup(udev_enumerate_unrefp))) struct udev_enumerate *e = NULL((void*)0);
      struct udev_list_entry *first, *item;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1213
, __PRETTY_FUNCTION__); } while (0);

      e = udev_enumerate_new(m->udev);
      if (!e)
              return -ENOMEM12;

      if (d) {
              r = udev_enumerate_add_match_parent(e, d);
              if (r < 0)
                      return r;
      }

      r = udev_enumerate_scan_devices(e);
      if (r < 0)
              return r;

      first = udev_enumerate_get_list_entry(e);
      udev_list_entry_foreach(item, first)for (item = first; item != ((void*)0); item = udev_list_entry_get_next
(item)) {
              _cleanup_free___attribute__((cleanup(freep))) char *t = NULL((void*)0);
              const char *p;

              p = udev_list_entry_get_name(item);

              t = strappend(p, "/uevent");
              if (!t)
                      return -ENOMEM12;

              (void) write_string_file(t, "change", 0);
      }

      return 0;
1244}

1246static int attach_device(Manager *m, const char *seat, const char *sysfs) {
      _cleanup_(udev_device_unrefp)__attribute__((cleanup(udev_device_unrefp))) struct udev_device *d = NULL((void*)0);
      _cleanup_free___attribute__((cleanup(freep))) char *rule = NULL((void*)0), *file = NULL((void*)0);
      const char *id_for_seat;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1252
, __PRETTY_FUNCTION__); } while (0);
      assert(seat)do { if ((__builtin_expect(!!(!(seat)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("seat"), "../src/login/logind-dbus.c", 1253
, __PRETTY_FUNCTION__); } while (0);
      assert(sysfs)do { if ((__builtin_expect(!!(!(sysfs)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("sysfs"), "../src/login/logind-dbus.c", 1254
, __PRETTY_FUNCTION__); } while (0);

      d = udev_device_new_from_syspath(m->udev, sysfs);
      if (!d)
              return -ENODEV19;

      if (!udev_device_has_tag(d, "seat"))
              return -ENODEV19;

      id_for_seat = udev_device_get_property_value(d, "ID_FOR_SEAT");
      if (!id_for_seat)
              return -ENODEV19;

      if (asprintf(&file, "/etc/udev/rules.d/72-seat-%s.rules", id_for_seat) < 0)
              return -ENOMEM12;

      if (asprintf(&rule, "TAG==\"seat\", ENV{ID_FOR_SEAT}==\"%s\", ENV{ID_SEAT}=\"%s\"", id_for_seat, seat) < 0)
              return -ENOMEM12;

      mkdir_p_label("/etc/udev/rules.d", 0755);
      r = write_string_file_atomic_label(file, rule);
      if (r < 0)
              return r;

      return trigger_device(m, d);
1279}

1281static int flush_devices(Manager *m) {
      _cleanup_closedir___attribute__((cleanup(closedirp))) DIR *d;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1284
, __PRETTY_FUNCTION__); } while (0);

      d = opendir("/etc/udev/rules.d");
      if (!d) {
              if (errno(*__errno_location ()) != ENOENT2)
                      log_warning_errno(errno, "Failed to open /etc/udev/rules.d: %m")({ int _level = ((4)), _e = (((*__errno_location ()))), _realm
 = (LOG_REALM_SYSTEMD); (log_get_max_level_realm(_realm) >=
 ((_level) & 0x07)) ? log_internal_realm(((_realm) <<
| (_level)), _e, "../src/login/logind-dbus.c", 1289, __func__
, "Failed to open /etc/udev/rules.d: %m") : -abs(_e); });
      } else {
              struct dirent *de;

              FOREACH_DIRENT_ALL(de, d, break)for ((*__errno_location ()) = 0, de = readdir(d);; (*__errno_location
 ()) = 0, de = readdir(d)) if (!de) { if ((*__errno_location (
)) > 0) { break; } break; } else {
                      if (!dirent_is_file(de))
                              continue;

                      if (!startswith(de->d_name, "72-seat-"))
                              continue;

                      if (!endswith(de->d_name, ".rules"))
                              continue;

                      if (unlinkat(dirfd(d), de->d_name, 0) < 0)
                              log_warning_errno(errno, "Failed to unlink %s: %m", de->d_name)({ int _level = ((4)), _e = (((*__errno_location ()))), _realm
 = (LOG_REALM_SYSTEMD); (log_get_max_level_realm(_realm) >=
 ((_level) & 0x07)) ? log_internal_realm(((_realm) <<
| (_level)), _e, "../src/login/logind-dbus.c", 1304, __func__
, "Failed to unlink %s: %m", de->d_name) : -abs(_e); });
              }
      }

      return trigger_device(m, NULL((void*)0));
1309}

1311static int method_attach_device(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      const char *sysfs, *seat;
      Manager *m = userdata;
      int interactive, r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 1316, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1317
, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "ssb", &seat, &sysfs, &interactive);
      if (r < 0)
              return r;

      if (!path_startswith(sysfs, "/sys"))
              return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Path %s is not in /sys", sysfs);

      if (!seat_name_is_valid(seat))
              return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Seat %s is not valid", seat);

      r = bus_verify_polkit_async(
                      message,
                      CAP_SYS_ADMIN21,
                      "org.freedesktop.login1.attach-device",
                      NULL((void*)0),
                      interactive,
                      UID_INVALID((uid_t) -1),
                      &m->polkit_registry,
                      error);
      if (r < 0)
              return r;
      if (r == 0)
              return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */

      r = attach_device(m, seat, sysfs);
      if (r < 0)
              return r;

      return sd_bus_reply_method_return(message, NULL((void*)0));
1348}

1350static int method_flush_devices(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;
      int interactive, r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 1354, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1355
, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "b", &interactive);
      if (r < 0)
              return r;

      r = bus_verify_polkit_async(
                      message,
                      CAP_SYS_ADMIN21,
                      "org.freedesktop.login1.flush-devices",
                      NULL((void*)0),
                      interactive,
                      UID_INVALID((uid_t) -1),
                      &m->polkit_registry,
                      error);
      if (r < 0)
              return r;
      if (r == 0)
              return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */

      r = flush_devices(m);
      if (r < 0)
              return r;

      return sd_bus_reply_method_return(message, NULL((void*)0));
1380}

1382static int have_multiple_sessions(
              Manager *m,
              uid_t uid) {

      Session *session;
      Iterator i;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1389
, __PRETTY_FUNCTION__); } while (0);

      /* Check for other users' sessions. Greeter sessions do not
       * count, and non-login sessions do not count either. */
      HASHMAP_FOREACH(session, m->sessions, i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((m->sessions), &
(i), (void**)&(session), ((void*)0)); )
              if (session->class == SESSION_USER &&
                  session->user->uid != uid)
                      return true1;

      return false0;
1399}

1401static int bus_manager_log_shutdown(
              Manager *m,
              const char *unit_name) {

      const char *p, *q;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1407
, __PRETTY_FUNCTION__); } while (0);
      assert(unit_name)do { if ((__builtin_expect(!!(!(unit_name)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("unit_name"), "../src/login/logind-dbus.c"
, 1408, __PRETTY_FUNCTION__); } while (0);

      if (streq(unit_name, SPECIAL_POWEROFF_TARGET)(strcmp((unit_name),("poweroff.target")) == 0)) {
              p = "MESSAGE=System is powering down";
              q = "SHUTDOWN=power-off";
      } else if (streq(unit_name, SPECIAL_REBOOT_TARGET)(strcmp((unit_name),("reboot.target")) == 0)) {
              p = "MESSAGE=System is rebooting";
              q = "SHUTDOWN=reboot";
      } else if (streq(unit_name, SPECIAL_HALT_TARGET)(strcmp((unit_name),("halt.target")) == 0)) {
              p = "MESSAGE=System is halting";
              q = "SHUTDOWN=halt";
      } else if (streq(unit_name, SPECIAL_KEXEC_TARGET)(strcmp((unit_name),("kexec.target")) == 0)) {
              p = "MESSAGE=System is rebooting with kexec";
              q = "SHUTDOWN=kexec";
      } else {
              p = "MESSAGE=System is shutting down";
              q = NULL((void*)0);
      }

      if (isempty(m->wall_message))
              p = strjoina(p, ".")({ const char *_appendees_[] = { p, "." }; char *_d_, *_p_; size_t
 _len_ = 0; size_t _i_; for (_i_ = 0; _i_ < __extension__ (
__builtin_choose_expr( !__builtin_types_compatible_p(typeof(_appendees_
), typeof(&*(_appendees_))), sizeof(_appendees_)/sizeof((
_appendees_)[0]), ((void)0))) && _appendees_[_i_]; _i_
++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
 (_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });
      else
              p = strjoina(p, " (", m->wall_message, ").")({ const char *_appendees_[] = { p, " (", m->wall_message,
 ")." }; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for (
_i_ = 0; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
 (_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

      return log_struct(LOG_NOTICE,log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (5)), 0
, "../src/login/logind-dbus.c", 1435, __func__, "MESSAGE_ID="
 "98" "26" "88" "66" "d1" "d5" "4a" "49" "9c" "4e" "98" "92" "1d"
 "93" "bc" "40", p, q, ((void*)0))
                        "MESSAGE_ID=" SD_MESSAGE_SHUTDOWN_STR,log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (5)), 0
, "../src/login/logind-dbus.c", 1435, __func__, "MESSAGE_ID="
 "98" "26" "88" "66" "d1" "d5" "4a" "49" "9c" "4e" "98" "92" "1d"
 "93" "bc" "40", p, q, ((void*)0))
                        p,log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (5)), 0
, "../src/login/logind-dbus.c", 1435, __func__, "MESSAGE_ID="
 "98" "26" "88" "66" "d1" "d5" "4a" "49" "9c" "4e" "98" "92" "1d"
 "93" "bc" "40", p, q, ((void*)0))
                        q)log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (5)), 0
, "../src/login/logind-dbus.c", 1435, __func__, "MESSAGE_ID="
 "98" "26" "88" "66" "d1" "d5" "4a" "49" "9c" "4e" "98" "92" "1d"
 "93" "bc" "40", p, q, ((void*)0));
1436}

1438static int lid_switch_ignore_handler(sd_event_source *e, uint64_t usec, void *userdata) {
      Manager *m = userdata;

      assert(e)do { if ((__builtin_expect(!!(!(e)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("e"), "../src/login/logind-dbus.c", 1441
, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1442
, __PRETTY_FUNCTION__); } while (0);

      m->lid_switch_ignore_event_source = sd_event_source_unref(m->lid_switch_ignore_event_source);
      return 0;
1446}

1448int manager_set_lid_switch_ignore(Manager *m, usec_t until) {
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1451
, __PRETTY_FUNCTION__); } while (0);

      if (until <= now(CLOCK_MONOTONIC1))
              return 0;

      /* We want to ignore the lid switch for a while after each
       * suspend, and after boot-up. Hence let's install a timer for
       * this. As long as the event source exists we ignore the lid
       * switch. */

      if (m->lid_switch_ignore_event_source) {
              usec_t u;

              r = sd_event_source_get_time(m->lid_switch_ignore_event_source, &u);
              if (r < 0)
                      return r;

              if (until <= u)
                      return 0;

              r = sd_event_source_set_time(m->lid_switch_ignore_event_source, until);
      } else
              r = sd_event_add_time(
                              m->event,
                              &m->lid_switch_ignore_event_source,
                              CLOCK_MONOTONIC1,
                              until, 0,
                              lid_switch_ignore_handler, m);

      return r;
1481}

1483static int send_prepare_for(Manager *m, InhibitWhat w, bool_Bool _active) {

      static const char * const signal_name[_INHIBIT_WHAT_MAX] = {
              [INHIBIT_SHUTDOWN] = "PrepareForShutdown",
              [INHIBIT_SLEEP] = "PrepareForSleep"
      };

      int active = _active;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1492
, __PRETTY_FUNCTION__); } while (0);
      assert(w >= 0)do { if ((__builtin_expect(!!(!(w >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("w >= 0"), "../src/login/logind-dbus.c"
, 1493, __PRETTY_FUNCTION__); } while (0);
      assert(w < _INHIBIT_WHAT_MAX)do { if ((__builtin_expect(!!(!(w < _INHIBIT_WHAT_MAX)),0)
)) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("w < _INHIBIT_WHAT_MAX"
), "../src/login/logind-dbus.c", 1494, __PRETTY_FUNCTION__); }
 while (0);
      assert(signal_name[w])do { if ((__builtin_expect(!!(!(signal_name[w])),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("signal_name[w]"), "../src/login/logind-dbus.c"
, 1495, __PRETTY_FUNCTION__); } while (0);

      return sd_bus_emit_signal(m->bus,
                                "/org/freedesktop/login1",
                                "org.freedesktop.login1.Manager",
                                signal_name[w],
                                "b",
                                active);
1503}

1505static int execute_shutdown_or_sleep(
              Manager *m,
              InhibitWhat w,
              const char *unit_name,
              sd_bus_error *error) {

      _cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *reply = NULL((void*)0);
      char *c = NULL((void*)0);
      const char *p;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1516
, __PRETTY_FUNCTION__); } while (0);
      assert(w > 0)do { if ((__builtin_expect(!!(!(w > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("w > 0"), "../src/login/logind-dbus.c"
, 1517, __PRETTY_FUNCTION__); } while (0);
      assert(w < _INHIBIT_WHAT_MAX)do { if ((__builtin_expect(!!(!(w < _INHIBIT_WHAT_MAX)),0)
)) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("w < _INHIBIT_WHAT_MAX"
), "../src/login/logind-dbus.c", 1518, __PRETTY_FUNCTION__); }
 while (0);
      assert(unit_name)do { if ((__builtin_expect(!!(!(unit_name)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("unit_name"), "../src/login/logind-dbus.c"
, 1519, __PRETTY_FUNCTION__); } while (0);

      if (w == INHIBIT_SHUTDOWN)
              bus_manager_log_shutdown(m, unit_name);

      r = sd_bus_call_method(
                      m->bus,
                      "org.freedesktop.systemd1",
                      "/org/freedesktop/systemd1",
                      "org.freedesktop.systemd1.Manager",
                      "StartUnit",
                      error,
                      &reply,
                      "ss", unit_name, "replace-irreversibly");
      if (r < 0)
              goto error;

      r = sd_bus_message_read(reply, "o", &p);
      if (r < 0)
              goto error;

      c = strdup(p);
      if (!c) {
              r = -ENOMEM12;
              goto error;
      }

      m->action_unit = unit_name;
      free(m->action_job);
      m->action_job = c;
      m->action_what = w;

      /* Make sure the lid switch is ignored for a while */
      manager_set_lid_switch_ignore(m, now(CLOCK_MONOTONIC1) + m->holdoff_timeout_usec);

      return 0;

1556error:
      /* Tell people that they now may take a lock again */
      (void) send_prepare_for(m, w, false0);

      return r;
1561}

1563int manager_dispatch_delayed(Manager *manager, bool_Bool timeout) {

      _cleanup_(sd_bus_error_free)__attribute__((cleanup(sd_bus_error_free))) sd_bus_error error = SD_BUS_ERROR_NULL((const sd_bus_error) {(((void*)0)), (((void*)0)), 0});
      Inhibitor *offending = NULL((void*)0);
      int r;

      assert(manager)do { if ((__builtin_expect(!!(!(manager)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("manager"), "../src/login/logind-dbus.c"
, 1569, __PRETTY_FUNCTION__); } while (0);

      if (manager->action_what == 0 || manager->action_job)
              return 0;

      if (manager_is_inhibited(manager, manager->action_what, INHIBIT_DELAY, NULL((void*)0), false0, false0, 0, &offending)) {
              _cleanup_free___attribute__((cleanup(freep))) char *comm = NULL((void*)0), *u = NULL((void*)0);

              if (!timeout)
                      return 0;

              (void) get_process_comm(offending->pid, &comm);
              u = uid_to_name(offending->uid);

              log_notice("Delay lock is active (UID "UID_FMT"/%s, PID "PID_FMT"/%s) but inhibitor timeout is reached.",({ int _level = (((5))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 1585, __func__, "Delay lock is active (UID "
"%" "u""/%s, PID ""%" "i""/%s) but inhibitor timeout is reached."
, offending->uid, strna(u), offending->pid, strna(comm)
) : -abs(_e); })
                         offending->uid, strna(u),({ int _level = (((5))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 1585, __func__, "Delay lock is active (UID "
"%" "u""/%s, PID ""%" "i""/%s) but inhibitor timeout is reached."
, offending->uid, strna(u), offending->pid, strna(comm)
) : -abs(_e); })
                         offending->pid, strna(comm))({ int _level = (((5))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 1585, __func__, "Delay lock is active (UID "
"%" "u""/%s, PID ""%" "i""/%s) but inhibitor timeout is reached."
, offending->uid, strna(u), offending->pid, strna(comm)
) : -abs(_e); });
      }

      /* Actually do the operation */
      r = execute_shutdown_or_sleep(manager, manager->action_what, manager->action_unit, &error);
      if (r < 0) {
              log_warning("Error during inhibitor-delayed operation (already returned success to client): %s",({ int _level = (((4))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 1592, __func__, "Error during inhibitor-delayed operation (already returned success to client): %s"
, bus_error_message(&error, r)) : -abs(_e); })
                          bus_error_message(&error, r))({ int _level = (((4))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 1592, __func__, "Error during inhibitor-delayed operation (already returned success to client): %s"
, bus_error_message(&error, r)) : -abs(_e); });

              manager->action_unit = NULL((void*)0);
              manager->action_what = 0;
              return r;
      }

      return 1;
1600}

1602static int manager_inhibit_timeout_handler(
                      sd_event_source *s,
                      uint64_t usec,
                      void *userdata) {

      Manager *manager = userdata;
      int r;

      assert(manager)do { if ((__builtin_expect(!!(!(manager)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("manager"), "../src/login/logind-dbus.c"
, 1610, __PRETTY_FUNCTION__); } while (0);
      assert(manager->inhibit_timeout_source == s)do { if ((__builtin_expect(!!(!(manager->inhibit_timeout_source
 == s)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("manager->inhibit_timeout_source == s"
), "../src/login/logind-dbus.c", 1611, __PRETTY_FUNCTION__); }
 while (0);

      r = manager_dispatch_delayed(manager, true1);
      return (r < 0) ? r : 0;
1615}

1617static int delay_shutdown_or_sleep(
              Manager *m,
              InhibitWhat w,
              const char *unit_name) {

      int r;
      usec_t timeout_val;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1625
, __PRETTY_FUNCTION__); } while (0);
      assert(w >= 0)do { if ((__builtin_expect(!!(!(w >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("w >= 0"), "../src/login/logind-dbus.c"
, 1626, __PRETTY_FUNCTION__); } while (0);
      assert(w < _INHIBIT_WHAT_MAX)do { if ((__builtin_expect(!!(!(w < _INHIBIT_WHAT_MAX)),0)
)) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("w < _INHIBIT_WHAT_MAX"
), "../src/login/logind-dbus.c", 1627, __PRETTY_FUNCTION__); }
 while (0);
      assert(unit_name)do { if ((__builtin_expect(!!(!(unit_name)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("unit_name"), "../src/login/logind-dbus.c"
, 1628, __PRETTY_FUNCTION__); } while (0);

      timeout_val = now(CLOCK_MONOTONIC1) + m->inhibit_delay_max;

      if (m->inhibit_timeout_source) {
              r = sd_event_source_set_time(m->inhibit_timeout_source, timeout_val);
              if (r < 0)
                      return log_error_errno(r, "sd_event_source_set_time() failed: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 1635, __func__, "sd_event_source_set_time() failed: %m"
) : -abs(_e); });

              r = sd_event_source_set_enabled(m->inhibit_timeout_source, SD_EVENT_ONESHOT);
              if (r < 0)
                      return log_error_errno(r, "sd_event_source_set_enabled() failed: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 1639, __func__, "sd_event_source_set_enabled() failed: %m"
) : -abs(_e); });
      } else {
              r = sd_event_add_time(m->event, &m->inhibit_timeout_source, CLOCK_MONOTONIC1,
                                    timeout_val, 0, manager_inhibit_timeout_handler, m);
              if (r < 0)
                      return r;
      }

      m->action_unit = unit_name;
      m->action_what = w;

      return 0;
1651}

1653int bus_manager_shutdown_or_sleep_now_or_later(
              Manager *m,
              const char *unit_name,
              InhibitWhat w,
              sd_bus_error *error) {

      _cleanup_free___attribute__((cleanup(freep))) char *load_state = NULL((void*)0);
      bool_Bool delayed;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1663
, __PRETTY_FUNCTION__); } while (0);
      assert(unit_name)do { if ((__builtin_expect(!!(!(unit_name)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("unit_name"), "../src/login/logind-dbus.c"
, 1664, __PRETTY_FUNCTION__); } while (0);
      assert(w > 0)do { if ((__builtin_expect(!!(!(w > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("w > 0"), "../src/login/logind-dbus.c"
, 1665, __PRETTY_FUNCTION__); } while (0);
      assert(w <= _INHIBIT_WHAT_MAX)do { if ((__builtin_expect(!!(!(w <= _INHIBIT_WHAT_MAX)),0
))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("w <= _INHIBIT_WHAT_MAX"
), "../src/login/logind-dbus.c", 1666, __PRETTY_FUNCTION__); }
 while (0);
      assert(!m->action_job)do { if ((__builtin_expect(!!(!(!m->action_job)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("!m->action_job"), "../src/login/logind-dbus.c"
, 1667, __PRETTY_FUNCTION__); } while (0);

      r = unit_load_state(m->bus, unit_name, &load_state);
      if (r < 0)
              return r;

      if (!streq(load_state, "loaded")(strcmp((load_state),("loaded")) == 0)) {
              log_notice("Unit %s is %s, refusing operation.", unit_name, load_state)({ int _level = (((5))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 1674, __func__, "Unit %s is %s, refusing operation."
, unit_name, load_state) : -abs(_e); });
              return -EACCES13;
      }

      /* Tell everybody to prepare for shutdown/sleep */
      (void) send_prepare_for(m, w, true1);

      delayed =
              m->inhibit_delay_max > 0 &&
              manager_is_inhibited(m, w, INHIBIT_DELAY, NULL((void*)0), false0, false0, 0, NULL((void*)0));

      if (delayed)
              /* Shutdown is delayed, keep in mind what we
               * want to do, and start a timeout */
              r = delay_shutdown_or_sleep(m, w, unit_name);
      else
              /* Shutdown is not delayed, execute it
               * immediately */
              r = execute_shutdown_or_sleep(m, w, unit_name, error);

      return r;
1695}

1697static int verify_shutdown_creds(
              Manager *m,
              sd_bus_message *message,
              InhibitWhat w,
              bool_Bool interactive,
              const char *action,
              const char *action_multiple_sessions,
              const char *action_ignore_inhibit,
              sd_bus_error *error) {

      _cleanup_(sd_bus_creds_unrefp)__attribute__((cleanup(sd_bus_creds_unrefp))) sd_bus_creds *creds = NULL((void*)0);
      bool_Bool multiple_sessions, blocked;
      uid_t uid;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1712
, __PRETTY_FUNCTION__); } while (0);
      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 1713, __PRETTY_FUNCTION__); } while (0);
      assert(w >= 0)do { if ((__builtin_expect(!!(!(w >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("w >= 0"), "../src/login/logind-dbus.c"
, 1714, __PRETTY_FUNCTION__); } while (0);
      assert(w <= _INHIBIT_WHAT_MAX)do { if ((__builtin_expect(!!(!(w <= _INHIBIT_WHAT_MAX)),0
))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("w <= _INHIBIT_WHAT_MAX"
), "../src/login/logind-dbus.c", 1715, __PRETTY_FUNCTION__); }
 while (0);

      r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID, &creds);
      if (r < 0)
              return r;

      r = sd_bus_creds_get_euid(creds, &uid);
      if (r < 0)
              return r;

      r = have_multiple_sessions(m, uid);
      if (r < 0)
              return r;

      multiple_sessions = r > 0;
      blocked = manager_is_inhibited(m, w, INHIBIT_BLOCK, NULL((void*)0), false0, true1, uid, NULL((void*)0));

      if (multiple_sessions && action_multiple_sessions) {
              r = bus_verify_polkit_async(message, CAP_SYS_BOOT22, action_multiple_sessions, NULL((void*)0), interactive, UID_INVALID((uid_t) -1), &m->polkit_registry, error);
              if (r < 0)
                      return r;
              if (r == 0)
                      return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
      }

      if (blocked && action_ignore_inhibit) {
              r = bus_verify_polkit_async(message, CAP_SYS_BOOT22, action_ignore_inhibit, NULL((void*)0), interactive, UID_INVALID((uid_t) -1), &m->polkit_registry, error);
              if (r < 0)
                      return r;
              if (r == 0)
                      return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
      }

      if (!multiple_sessions && !blocked && action) {
              r = bus_verify_polkit_async(message, CAP_SYS_BOOT22, action, NULL((void*)0), interactive, UID_INVALID((uid_t) -1), &m->polkit_registry, error);
              if (r < 0)
                      return r;
              if (r == 0)
                      return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
      }

      return 0;
1757}

1759static int method_do_shutdown_or_sleep(
              Manager *m,
              sd_bus_message *message,
              const char *unit_name,
              InhibitWhat w,
              const char *action,
              const char *action_multiple_sessions,
              const char *action_ignore_inhibit,
              const char *sleep_verb,
              sd_bus_error *error) {

      int interactive, r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1772
, __PRETTY_FUNCTION__); } while (0);
      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 1773, __PRETTY_FUNCTION__); } while (0);
      assert(unit_name)do { if ((__builtin_expect(!!(!(unit_name)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("unit_name"), "../src/login/logind-dbus.c"
, 1774, __PRETTY_FUNCTION__); } while (0);
      assert(w >= 0)do { if ((__builtin_expect(!!(!(w >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("w >= 0"), "../src/login/logind-dbus.c"
, 1775, __PRETTY_FUNCTION__); } while (0);
      assert(w <= _INHIBIT_WHAT_MAX)do { if ((__builtin_expect(!!(!(w <= _INHIBIT_WHAT_MAX)),0
))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("w <= _INHIBIT_WHAT_MAX"
), "../src/login/logind-dbus.c", 1776, __PRETTY_FUNCTION__); }
 while (0);

      r = sd_bus_message_read(message, "b", &interactive);
      if (r < 0)
              return r;

      /* Don't allow multiple jobs being executed at the same time */
      if (m->action_what)
              return sd_bus_error_setf(error, BUS_ERROR_OPERATION_IN_PROGRESS"org.freedesktop.login1.OperationInProgress", "There's already a shutdown or sleep operation in progress");

      if (sleep_verb) {
              r = can_sleep(sleep_verb);
              if (r == -ENOSPC28)
                      return sd_bus_error_set(error, BUS_ERROR_SLEEP_VERB_NOT_SUPPORTED"org.freedesktop.login1.SleepVerbNotSupported",
                                              "Not enough swap space for hibernation");
              if (r == 0)
                      return sd_bus_error_setf(error, BUS_ERROR_SLEEP_VERB_NOT_SUPPORTED"org.freedesktop.login1.SleepVerbNotSupported",
                                               "Sleep verb \"%s\" not supported", sleep_verb);
              if (r < 0)
                      return r;
      }

      r = verify_shutdown_creds(m, message, w, interactive, action, action_multiple_sessions,
                                action_ignore_inhibit, error);
      if (r != 0)
              return r;

      r = bus_manager_shutdown_or_sleep_now_or_later(m, unit_name, w, error);
      if (r < 0)
              return r;

      return sd_bus_reply_method_return(message, NULL((void*)0));
1808}

1810static int method_poweroff(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;

      return method_do_shutdown_or_sleep(
                      m, message,
                      SPECIAL_POWEROFF_TARGET"poweroff.target",
                      INHIBIT_SHUTDOWN,
                      "org.freedesktop.login1.power-off",
                      "org.freedesktop.login1.power-off-multiple-sessions",
                      "org.freedesktop.login1.power-off-ignore-inhibit",
                      NULL((void*)0),
                      error);
1822}

1824static int method_reboot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;

      return method_do_shutdown_or_sleep(
                      m, message,
                      SPECIAL_REBOOT_TARGET"reboot.target",
                      INHIBIT_SHUTDOWN,
                      "org.freedesktop.login1.reboot",
                      "org.freedesktop.login1.reboot-multiple-sessions",
                      "org.freedesktop.login1.reboot-ignore-inhibit",
                      NULL((void*)0),
                      error);
1836}

1838static int method_halt(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;

      return method_do_shutdown_or_sleep(
                      m, message,
                      SPECIAL_HALT_TARGET"halt.target",
                      INHIBIT_SHUTDOWN,
                      "org.freedesktop.login1.halt",
                      "org.freedesktop.login1.halt-multiple-sessions",
                      "org.freedesktop.login1.halt-ignore-inhibit",
                      NULL((void*)0),
                      error);
1850}

1852static int method_suspend(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;

      return method_do_shutdown_or_sleep(
                      m, message,
                      SPECIAL_SUSPEND_TARGET"suspend.target",
                      INHIBIT_SLEEP,
                      "org.freedesktop.login1.suspend",
                      "org.freedesktop.login1.suspend-multiple-sessions",
                      "org.freedesktop.login1.suspend-ignore-inhibit",
                      "suspend",
                      error);
1864}

1866static int method_hibernate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;

      return method_do_shutdown_or_sleep(
                      m, message,
                      SPECIAL_HIBERNATE_TARGET"hibernate.target",
                      INHIBIT_SLEEP,
                      "org.freedesktop.login1.hibernate",
                      "org.freedesktop.login1.hibernate-multiple-sessions",
                      "org.freedesktop.login1.hibernate-ignore-inhibit",
                      "hibernate",
                      error);
1878}

1880static int method_hybrid_sleep(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;

      return method_do_shutdown_or_sleep(
                      m, message,
                      SPECIAL_HYBRID_SLEEP_TARGET"hybrid-sleep.target",
                      INHIBIT_SLEEP,
                      "org.freedesktop.login1.hibernate",
                      "org.freedesktop.login1.hibernate-multiple-sessions",
                      "org.freedesktop.login1.hibernate-ignore-inhibit",
                      "hybrid-sleep",
                      error);
1892}

1894static int method_suspend_then_hibernate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;

      return method_do_shutdown_or_sleep(
                      m, message,
                      SPECIAL_SUSPEND_THEN_HIBERNATE_TARGET"suspend-then-hibernate.target",
                      INHIBIT_SLEEP,
                      "org.freedesktop.login1.hibernate",
                      "org.freedesktop.login1.hibernate-multiple-sessions",
                      "org.freedesktop.login1.hibernate-ignore-inhibit",
                      "hybrid-sleep",
                      error);
1906}

1908static int nologin_timeout_handler(
                      sd_event_source *s,
                      uint64_t usec,
                      void *userdata) {

      Manager *m = userdata;

      log_info("Creating /run/nologin, blocking further logins...")({ int _level = (((6))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 1915, __func__, "Creating /run/nologin, blocking further logins..."
) : -abs(_e); });

      m->unlink_nologin =
              create_shutdown_run_nologin_or_warn() >= 0;

      return 0;
1921}

1923static int update_schedule_file(Manager *m) {
      _cleanup_free___attribute__((cleanup(freep))) char *temp_path = NULL((void*)0);
      _cleanup_fclose___attribute__((cleanup(fclosep))) FILE *f = NULL((void*)0);
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1928
, __PRETTY_FUNCTION__); } while (0);

      r = mkdir_safe_label("/run/systemd/shutdown", 0755, 0, 0, MKDIR_WARN_MODE);
      if (r < 0)
              return log_error_errno(r, "Failed to create shutdown subdirectory: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 1932, __func__, "Failed to create shutdown subdirectory: %m"
) : -abs(_e); });

      r = fopen_temporary("/run/systemd/shutdown/scheduled", &f, &temp_path);
      if (r < 0)
              return log_error_errno(r, "Failed to save information about scheduled shutdowns: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 1936, __func__, "Failed to save information about scheduled shutdowns: %m"
) : -abs(_e); });

      (void) fchmod(fileno(f), 0644);

      fprintf(f,
              "USEC="USEC_FMT"%" "l" "u""\n"
              "WARN_WALL=%i\n"
              "MODE=%s\n",
              m->scheduled_shutdown_timeout,
              m->enable_wall_messages,
              m->scheduled_shutdown_type);

      if (!isempty(m->wall_message)) {
              _cleanup_free___attribute__((cleanup(freep))) char *t;

              t = cescape(m->wall_message);
              if (!t) {
                      r = -ENOMEM12;
                      goto fail;
              }

              fprintf(f, "WALL_MESSAGE=%s\n", t);
      }

      r = fflush_and_check(f);
      if (r < 0)
              goto fail;

      if (rename(temp_path, "/run/systemd/shutdown/scheduled") < 0) {
              r = -errno(*__errno_location ());
              goto fail;
      }

      return 0;

1971fail:
      (void) unlink(temp_path);
      (void) unlink("/run/systemd/shutdown/scheduled");

      return log_error_errno(r, "Failed to write information about scheduled shutdowns: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 1975, __func__, "Failed to write information about scheduled shutdowns: %m"
) : -abs(_e); });
1976}

1978static void reset_scheduled_shutdown(Manager *m) {
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 1979
, __PRETTY_FUNCTION__); } while (0);

      m->scheduled_shutdown_timeout_source = sd_event_source_unref(m->scheduled_shutdown_timeout_source);
      m->wall_message_timeout_source = sd_event_source_unref(m->wall_message_timeout_source);
      m->nologin_timeout_source = sd_event_source_unref(m->nologin_timeout_source);

      m->scheduled_shutdown_type = mfree(m->scheduled_shutdown_type);
      m->scheduled_shutdown_timeout = 0;
      m->shutdown_dry_run = false0;

      if (m->unlink_nologin) {
              (void) unlink_or_warn("/run/nologin");
              m->unlink_nologin = false0;
      }

      (void) unlink("/run/systemd/shutdown/scheduled");
1995}

1997static int manager_scheduled_shutdown_handler(
                      sd_event_source *s,
                      uint64_t usec,
                      void *userdata) {

      _cleanup_(sd_bus_error_free)__attribute__((cleanup(sd_bus_error_free))) sd_bus_error error = SD_BUS_ERROR_NULL((const sd_bus_error) {(((void*)0)), (((void*)0)), 0});
      Manager *m = userdata;
      const char *target;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 2007
, __PRETTY_FUNCTION__); } while (0);

      if (isempty(m->scheduled_shutdown_type))
              return 0;

      if (streq(m->scheduled_shutdown_type, "poweroff")(strcmp((m->scheduled_shutdown_type),("poweroff")) == 0))
              target = SPECIAL_POWEROFF_TARGET"poweroff.target";
      else if (streq(m->scheduled_shutdown_type, "reboot")(strcmp((m->scheduled_shutdown_type),("reboot")) == 0))
              target = SPECIAL_REBOOT_TARGET"reboot.target";
      else if (streq(m->scheduled_shutdown_type, "halt")(strcmp((m->scheduled_shutdown_type),("halt")) == 0))
              target = SPECIAL_HALT_TARGET"halt.target";
      else
              assert_not_reached("unexpected shutdown type")do { log_assert_failed_unreachable_realm(LOG_REALM_SYSTEMD, (
"unexpected shutdown type"), "../src/login/logind-dbus.c", 2019
, __PRETTY_FUNCTION__); } while (0);

      /* Don't allow multiple jobs being executed at the same time */
      if (m->action_what) {
              r = -EALREADY114;
              log_error("Scheduled shutdown to %s failed: shutdown or sleep operation already in progress", target)({ int _level = (((3))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 2024, __func__, "Scheduled shutdown to %s failed: shutdown or sleep operation already in progress"
, target) : -abs(_e); });
              goto error;
      }

      if (m->shutdown_dry_run) {
              /* We do not process delay inhibitors here.  Otherwise, we
               * would have to be considered "in progress" (like the check
               * above) for some seconds after our admin has seen the final
               * wall message. */

              bus_manager_log_shutdown(m, target);
              log_info("Running in dry run, suppressing action.")({ int _level = (((6))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 2035, __func__, "Running in dry run, suppressing action."
) : -abs(_e); });
              reset_scheduled_shutdown(m);

              return 0;
      }

      r = bus_manager_shutdown_or_sleep_now_or_later(m, target, INHIBIT_SHUTDOWN, &error);
      if (r < 0) {
              log_error_errno(r, "Scheduled shutdown to %s failed: %m", target)({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 2043, __func__, "Scheduled shutdown to %s failed: %m"
, target) : -abs(_e); });
              goto error;
      }

      return 0;

2049error:
      reset_scheduled_shutdown(m);
      return r;
2052}

2054static int method_schedule_shutdown(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;
      _cleanup_(sd_bus_creds_unrefp)__attribute__((cleanup(sd_bus_creds_unrefp))) sd_bus_creds *creds = NULL((void*)0);
      const char *action_multiple_sessions = NULL((void*)0);
      const char *action_ignore_inhibit = NULL((void*)0);
      const char *action = NULL((void*)0);
      uint64_t elapse;
      char *type;
      int r;
      bool_Bool dry_run = false0;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 2065
, __PRETTY_FUNCTION__); } while (0);
      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 2066, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "st", &type, &elapse);
      if (r < 0)
              return r;

      if (startswith(type, "dry-")) {
              type += 4;
              dry_run = true1;
      }

      if (streq(type, "poweroff")(strcmp((type),("poweroff")) == 0)) {
              action = "org.freedesktop.login1.power-off";
              action_multiple_sessions = "org.freedesktop.login1.power-off-multiple-sessions";
              action_ignore_inhibit = "org.freedesktop.login1.power-off-ignore-inhibit";
      } else if (streq(type, "reboot")(strcmp((type),("reboot")) == 0)) {
              action = "org.freedesktop.login1.reboot";
              action_multiple_sessions = "org.freedesktop.login1.reboot-multiple-sessions";
              action_ignore_inhibit = "org.freedesktop.login1.reboot-ignore-inhibit";
      } else if (streq(type, "halt")(strcmp((type),("halt")) == 0)) {
              action = "org.freedesktop.login1.halt";
              action_multiple_sessions = "org.freedesktop.login1.halt-multiple-sessions";
              action_ignore_inhibit = "org.freedesktop.login1.halt-ignore-inhibit";
      } else
              return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Unsupported shutdown type");

      r = verify_shutdown_creds(m, message, INHIBIT_SHUTDOWN, false0,
                                action, action_multiple_sessions, action_ignore_inhibit, error);
      if (r != 0)
              return r;

      if (m->scheduled_shutdown_timeout_source) {
              r = sd_event_source_set_time(m->scheduled_shutdown_timeout_source, elapse);
              if (r < 0)
                      return log_error_errno(r, "sd_event_source_set_time() failed: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 2100, __func__, "sd_event_source_set_time() failed: %m"
) : -abs(_e); });

              r = sd_event_source_set_enabled(m->scheduled_shutdown_timeout_source, SD_EVENT_ONESHOT);
              if (r < 0)
                      return log_error_errno(r, "sd_event_source_set_enabled() failed: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 2104, __func__, "sd_event_source_set_enabled() failed: %m"
) : -abs(_e); });
      } else {
              r = sd_event_add_time(m->event, &m->scheduled_shutdown_timeout_source,
                                    CLOCK_REALTIME0, elapse, 0, manager_scheduled_shutdown_handler, m);
              if (r < 0)
                      return log_error_errno(r, "sd_event_add_time() failed: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 2109, __func__, "sd_event_add_time() failed: %m"
) : -abs(_e); });
      }

      r = free_and_strdup(&m->scheduled_shutdown_type, type);
      if (r < 0) {
              m->scheduled_shutdown_timeout_source = sd_event_source_unref(m->scheduled_shutdown_timeout_source);
              return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/login/logind-dbus.c"
, 2115, __func__);
      }

      m->shutdown_dry_run = dry_run;

      if (m->nologin_timeout_source) {
              r = sd_event_source_set_time(m->nologin_timeout_source, elapse);
              if (r < 0)
                      return log_error_errno(r, "sd_event_source_set_time() failed: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 2123, __func__, "sd_event_source_set_time() failed: %m"
) : -abs(_e); });

              r = sd_event_source_set_enabled(m->nologin_timeout_source, SD_EVENT_ONESHOT);
              if (r < 0)
                      return log_error_errno(r, "sd_event_source_set_enabled() failed: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 2127, __func__, "sd_event_source_set_enabled() failed: %m"
) : -abs(_e); });
      } else {
              r = sd_event_add_time(m->event, &m->nologin_timeout_source,
                                    CLOCK_REALTIME0, elapse - 5 * USEC_PER_MINUTE((usec_t) (60ULL*((usec_t) 1000000ULL))), 0, nologin_timeout_handler, m);
              if (r < 0)
                      return log_error_errno(r, "sd_event_add_time() failed: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 2132, __func__, "sd_event_add_time() failed: %m"
) : -abs(_e); });
      }

      m->scheduled_shutdown_timeout = elapse;

      r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_AUGMENT|SD_BUS_CREDS_TTY|SD_BUS_CREDS_UID, &creds);
      if (r >= 0) {
              const char *tty = NULL((void*)0);

              (void) sd_bus_creds_get_uid(creds, &m->scheduled_shutdown_uid);
              (void) sd_bus_creds_get_tty(creds, &tty);

              r = free_and_strdup(&m->scheduled_shutdown_tty, tty);
              if (r < 0) {
                      m->scheduled_shutdown_timeout_source = sd_event_source_unref(m->scheduled_shutdown_timeout_source);
                      return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/login/logind-dbus.c"
, 2147, __func__);
              }
      }

      r = manager_setup_wall_message_timer(m);
      if (r < 0)
              return r;

      r = update_schedule_file(m);
      if (r < 0)
              return r;

      return sd_bus_reply_method_return(message, NULL((void*)0));
2160}

2162static int method_cancel_scheduled_shutdown(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;
      bool_Bool cancelled;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 2166
, __PRETTY_FUNCTION__); } while (0);
      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 2167, __PRETTY_FUNCTION__); } while (0);

      cancelled = m->scheduled_shutdown_type != NULL((void*)0);
      reset_scheduled_shutdown(m);

      if (cancelled && m->enable_wall_messages) {
              _cleanup_(sd_bus_creds_unrefp)__attribute__((cleanup(sd_bus_creds_unrefp))) sd_bus_creds *creds = NULL((void*)0);
              _cleanup_free___attribute__((cleanup(freep))) char *username = NULL((void*)0);
              const char *tty = NULL((void*)0);
              uid_t uid = 0;
              int r;

              r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_AUGMENT|SD_BUS_CREDS_TTY|SD_BUS_CREDS_UID, &creds);
              if (r >= 0) {
                      (void) sd_bus_creds_get_uid(creds, &uid);
                      (void) sd_bus_creds_get_tty(creds, &tty);
              }

              username = uid_to_name(uid);
              utmp_wall("The system shutdown has been cancelled",
                        username, tty, logind_wall_tty_filter, m);
      }

      return sd_bus_reply_method_return(message, "b", cancelled);
2191}

2193static int method_can_shutdown_or_sleep(
              Manager *m,
              sd_bus_message *message,
              InhibitWhat w,
              const char *action,
              const char *action_multiple_sessions,
              const char *action_ignore_inhibit,
              const char *sleep_verb,
              sd_bus_error *error) {

      _cleanup_(sd_bus_creds_unrefp)__attribute__((cleanup(sd_bus_creds_unrefp))) sd_bus_creds *creds = NULL((void*)0);
      HandleAction handle;
      bool_Bool multiple_sessions, challenge, blocked;
      const char *result = NULL((void*)0);
      uid_t uid;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 2210
, __PRETTY_FUNCTION__); } while (0);
      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 2211, __PRETTY_FUNCTION__); } while (0);
      assert(w >= 0)do { if ((__builtin_expect(!!(!(w >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("w >= 0"), "../src/login/logind-dbus.c"
, 2212, __PRETTY_FUNCTION__); } while (0);
      assert(w <= _INHIBIT_WHAT_MAX)do { if ((__builtin_expect(!!(!(w <= _INHIBIT_WHAT_MAX)),0
))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("w <= _INHIBIT_WHAT_MAX"
), "../src/login/logind-dbus.c", 2213, __PRETTY_FUNCTION__); }
 while (0);
      assert(action)do { if ((__builtin_expect(!!(!(action)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("action"), "../src/login/logind-dbus.c",
 2214, __PRETTY_FUNCTION__); } while (0);
      assert(action_multiple_sessions)do { if ((__builtin_expect(!!(!(action_multiple_sessions)),0)
)) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("action_multiple_sessions"
), "../src/login/logind-dbus.c", 2215, __PRETTY_FUNCTION__); }
 while (0);
      assert(action_ignore_inhibit)do { if ((__builtin_expect(!!(!(action_ignore_inhibit)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("action_ignore_inhibit"), "../src/login/logind-dbus.c"
, 2216, __PRETTY_FUNCTION__); } while (0);

      if (sleep_verb) {
              r = can_sleep(sleep_verb);
              if (IN_SET(r,  0, -ENOSPC)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){0, -28})/sizeof(int)]; switch(r) { case 0
: case -28: _found = 1; break; default: break; } _found; }))
                      return sd_bus_reply_method_return(message, "s", "na");
              if (r < 0)
                      return r;
      }

      r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID, &creds);
      if (r < 0)
              return r;

      r = sd_bus_creds_get_euid(creds, &uid);
      if (r < 0)
              return r;

      r = have_multiple_sessions(m, uid);
      if (r < 0)
              return r;

      multiple_sessions = r > 0;
      blocked = manager_is_inhibited(m, w, INHIBIT_BLOCK, NULL((void*)0), false0, true1, uid, NULL((void*)0));

      handle = handle_action_from_string(sleep_verb);
      if (handle >= 0) {
              const char *target;

              target = manager_target_for_action(handle);
              if (target) {
                      _cleanup_free___attribute__((cleanup(freep))) char *load_state = NULL((void*)0);

                      r = unit_load_state(m->bus, target, &load_state);
                      if (r < 0)
                              return r;

                      if (!streq(load_state, "loaded")(strcmp((load_state),("loaded")) == 0)) {
                              result = "no";
                              goto finish;
                      }
              }
      }

      if (multiple_sessions) {
              r = bus_test_polkit(message, CAP_SYS_BOOT22, action_multiple_sessions, NULL((void*)0), UID_INVALID((uid_t) -1), &challenge, error);
              if (r < 0)
                      return r;

              if (r > 0)
                      result = "yes";
              else if (challenge)
                      result = "challenge";
              else
                      result = "no";
      }

      if (blocked) {
              r = bus_test_polkit(message, CAP_SYS_BOOT22, action_ignore_inhibit, NULL((void*)0), UID_INVALID((uid_t) -1), &challenge, error);
              if (r < 0)
                      return r;

              if (r > 0 && !result)
                      result = "yes";
              else if (challenge && (!result || streq(result, "yes")(strcmp((result),("yes")) == 0)))
                      result = "challenge";
              else
                      result = "no";
      }

      if (!multiple_sessions && !blocked) {
              /* If neither inhibit nor multiple sessions
               * apply then just check the normal policy */

              r = bus_test_polkit(message, CAP_SYS_BOOT22, action, NULL((void*)0), UID_INVALID((uid_t) -1), &challenge, error);
              if (r < 0)
                      return r;

              if (r > 0)
                      result = "yes";
              else if (challenge)
                      result = "challenge";
              else
                      result = "no";
      }

finish:
      return sd_bus_reply_method_return(message, "s", result);
2304}

2306static int method_can_poweroff(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;

      return method_can_shutdown_or_sleep(
                      m, message,
                      INHIBIT_SHUTDOWN,
                      "org.freedesktop.login1.power-off",
                      "org.freedesktop.login1.power-off-multiple-sessions",
                      "org.freedesktop.login1.power-off-ignore-inhibit",
                      NULL((void*)0),
                      error);
2317}

2319static int method_can_reboot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;

      return method_can_shutdown_or_sleep(
                      m, message,
                      INHIBIT_SHUTDOWN,
                      "org.freedesktop.login1.reboot",
                      "org.freedesktop.login1.reboot-multiple-sessions",
                      "org.freedesktop.login1.reboot-ignore-inhibit",
                      NULL((void*)0),
                      error);
2330}

2332static int method_can_halt(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;

      return method_can_shutdown_or_sleep(
                      m, message,
                      INHIBIT_SHUTDOWN,
                      "org.freedesktop.login1.halt",
                      "org.freedesktop.login1.halt-multiple-sessions",
                      "org.freedesktop.login1.halt-ignore-inhibit",
                      NULL((void*)0),
                      error);
2343}

2345static int method_can_suspend(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;

      return method_can_shutdown_or_sleep(
                      m, message,
                      INHIBIT_SLEEP,
                      "org.freedesktop.login1.suspend",
                      "org.freedesktop.login1.suspend-multiple-sessions",
                      "org.freedesktop.login1.suspend-ignore-inhibit",
                      "suspend",
                      error);
2356}

2358static int method_can_hibernate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;

      return method_can_shutdown_or_sleep(
                      m, message,
                      INHIBIT_SLEEP,
                      "org.freedesktop.login1.hibernate",
                      "org.freedesktop.login1.hibernate-multiple-sessions",
                      "org.freedesktop.login1.hibernate-ignore-inhibit",
                      "hibernate",
                      error);
2369}

2371static int method_can_hybrid_sleep(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;

      return method_can_shutdown_or_sleep(
                      m, message,
                      INHIBIT_SLEEP,
                      "org.freedesktop.login1.hibernate",
                      "org.freedesktop.login1.hibernate-multiple-sessions",
                      "org.freedesktop.login1.hibernate-ignore-inhibit",
                      "hybrid-sleep",
                      error);
2382}

2384static int method_can_suspend_then_hibernate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;

      return method_can_shutdown_or_sleep(
                      m, message,
                      INHIBIT_SLEEP,
                      "org.freedesktop.login1.hibernate",
                      "org.freedesktop.login1.hibernate-multiple-sessions",
                      "org.freedesktop.login1.hibernate-ignore-inhibit",
                      "suspend-then-hibernate",
                      error);
2395}

2397static int property_get_reboot_to_firmware_setup(
              sd_bus *bus,
              const char *path,
              const char *interface,
              const char *property,
              sd_bus_message *reply,
              void *userdata,
              sd_bus_error *error) {
      int r;

      assert(bus)do { if ((__builtin_expect(!!(!(bus)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/login/logind-dbus.c", 2407
, __PRETTY_FUNCTION__); } while (0);
      assert(reply)do { if ((__builtin_expect(!!(!(reply)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("reply"), "../src/login/logind-dbus.c", 2408
, __PRETTY_FUNCTION__); } while (0);
      assert(userdata)do { if ((__builtin_expect(!!(!(userdata)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("userdata"), "../src/login/logind-dbus.c"
, 2409, __PRETTY_FUNCTION__); } while (0);

      r = efi_get_reboot_to_firmware();
      if (r < 0 && r != -EOPNOTSUPP95)
              log_warning_errno(r, "Failed to determine reboot-to-firmware state: %m")({ int _level = ((4)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 2413, __func__, "Failed to determine reboot-to-firmware state: %m"
) : -abs(_e); });

      return sd_bus_message_append(reply, "b", r > 0);
2416}

2418static int method_set_reboot_to_firmware_setup(
              sd_bus_message *message,
              void *userdata,
              sd_bus_error *error) {

      int b, r;
      Manager *m = userdata;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 2426, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 2427
, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "b", &b);
      if (r < 0)
              return r;

      r = bus_verify_polkit_async(message,
                                  CAP_SYS_ADMIN21,
                                  "org.freedesktop.login1.set-reboot-to-firmware-setup",
                                  NULL((void*)0),
                                  false0,
                                  UID_INVALID((uid_t) -1),
                                  &m->polkit_registry,
                                  error);
      if (r < 0)
              return r;
      if (r == 0)
              return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */

      r = efi_set_reboot_to_firmware(b);
      if (r < 0)
              return r;

      return sd_bus_reply_method_return(message, NULL((void*)0));
2451}

2453static int method_can_reboot_to_firmware_setup(
              sd_bus_message *message,
              void *userdata,
              sd_bus_error *error) {

      int r;
      bool_Bool challenge;
      const char *result;
      Manager *m = userdata;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 2463, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 2464
, __PRETTY_FUNCTION__); } while (0);

      r = efi_reboot_to_firmware_supported();
      if (r < 0) {
              if (r != -EOPNOTSUPP95)
                      log_warning_errno(errno, "Failed to determine whether reboot to firmware is supported: %m")({ int _level = ((4)), _e = (((*__errno_location ()))), _realm
 = (LOG_REALM_SYSTEMD); (log_get_max_level_realm(_realm) >=
 ((_level) & 0x07)) ? log_internal_realm(((_realm) <<
| (_level)), _e, "../src/login/logind-dbus.c", 2469, __func__
, "Failed to determine whether reboot to firmware is supported: %m"
) : -abs(_e); });

              return sd_bus_reply_method_return(message, "s", "na");
      }

      r = bus_test_polkit(message,
                          CAP_SYS_ADMIN21,
                          "org.freedesktop.login1.set-reboot-to-firmware-setup",
                          NULL((void*)0),
                          UID_INVALID((uid_t) -1),
                          &challenge,
                          error);
      if (r < 0)
              return r;

      if (r > 0)
              result = "yes";
      else if (challenge)
              result = "challenge";
      else
              result = "no";

      return sd_bus_reply_method_return(message, "s", result);
2492}

2494static int method_set_wall_message(
              sd_bus_message *message,
              void *userdata,
              sd_bus_error *error) {

      int r;
      Manager *m = userdata;
      char *wall_message;
      unsigned enable_wall_messages;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 2504, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 2505
, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "sb", &wall_message, &enable_wall_messages);
      if (r < 0)
              return r;

      r = bus_verify_polkit_async(message,
                                  CAP_SYS_ADMIN21,
                                  "org.freedesktop.login1.set-wall-message",
                                  NULL((void*)0),
                                  false0,
                                  UID_INVALID((uid_t) -1),
                                  &m->polkit_registry,
                                  error);
      if (r < 0)
              return r;
      if (r == 0)
              return 1; /* Will call us back */

      r = free_and_strdup(&m->wall_message, empty_to_null(wall_message));
      if (r < 0)
              return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/login/logind-dbus.c"
, 2526, __func__);

      m->enable_wall_messages = enable_wall_messages;

      return sd_bus_reply_method_return(message, NULL((void*)0));
2531}

2533static int method_inhibit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      _cleanup_(sd_bus_creds_unrefp)__attribute__((cleanup(sd_bus_creds_unrefp))) sd_bus_creds *creds = NULL((void*)0);
      const char *who, *why, *what, *mode;
      _cleanup_free___attribute__((cleanup(freep))) char *id = NULL((void*)0);
      _cleanup_close___attribute__((cleanup(closep))) int fifo_fd = -1;
      Manager *m = userdata;
      Inhibitor *i = NULL((void*)0);
      InhibitMode mm;
      InhibitWhat w;
      pid_t pid;
      uid_t uid;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 2546, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 2547
, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "ssss", &what, &who, &why, &mode);
      if (r < 0)
              return r;

      w = inhibit_what_from_string(what);
      if (w <= 0)
              return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Invalid what specification %s", what);

      mm = inhibit_mode_from_string(mode);
      if (mm < 0)
              return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Invalid mode specification %s", mode);

      /* Delay is only supported for shutdown/sleep */
      if (mm == INHIBIT_DELAY && (w & ~(INHIBIT_SHUTDOWN|INHIBIT_SLEEP)))
              return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Delay inhibitors only supported for shutdown and sleep");

      /* Don't allow taking delay locks while we are already
       * executing the operation. We shouldn't create the impression
       * that the lock was successful if the machine is about to go
       * down/suspend any moment. */
      if (m->action_what & w)
              return sd_bus_error_setf(error, BUS_ERROR_OPERATION_IN_PROGRESS"org.freedesktop.login1.OperationInProgress", "The operation inhibition has been requested for is already running");

      r = bus_verify_polkit_async(
                      message,
                      CAP_SYS_BOOT22,
                      w == INHIBIT_SHUTDOWN             ? (mm == INHIBIT_BLOCK ? "org.freedesktop.login1.inhibit-block-shutdown" : "org.freedesktop.login1.inhibit-delay-shutdown") :
                      w == INHIBIT_SLEEP                ? (mm == INHIBIT_BLOCK ? "org.freedesktop.login1.inhibit-block-sleep"    : "org.freedesktop.login1.inhibit-delay-sleep") :
                      w == INHIBIT_IDLE                 ? "org.freedesktop.login1.inhibit-block-idle" :
                      w == INHIBIT_HANDLE_POWER_KEY     ? "org.freedesktop.login1.inhibit-handle-power-key" :
                      w == INHIBIT_HANDLE_SUSPEND_KEY   ? "org.freedesktop.login1.inhibit-handle-suspend-key" :
                      w == INHIBIT_HANDLE_HIBERNATE_KEY ? "org.freedesktop.login1.inhibit-handle-hibernate-key" :
                                                          "org.freedesktop.login1.inhibit-handle-lid-switch",
                      NULL((void*)0),
                      false0,
                      UID_INVALID((uid_t) -1),
                      &m->polkit_registry,
                      error);
      if (r < 0)
              return r;
      if (r == 0)
              return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */

      r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID|SD_BUS_CREDS_PID, &creds);
      if (r < 0)
              return r;

      r = sd_bus_creds_get_euid(creds, &uid);
      if (r < 0)
              return r;

      r = sd_bus_creds_get_pid(creds, &pid);
      if (r < 0)
              return r;

      if (hashmap_size(m->inhibitors) >= m->inhibitors_max)
              return sd_bus_error_setf(error, SD_BUS_ERROR_LIMITS_EXCEEDED"org.freedesktop.DBus.Error.LimitsExceeded", "Maximum number of inhibitors (%" PRIu64"l" "u" ") reached, refusing further inhibitors.", m->inhibitors_max);

      do {
              id = mfree(id);

              if (asprintf(&id, "%lu", ++m->inhibit_counter) < 0)
                      return -ENOMEM12;

      } while (hashmap_get(m->inhibitors, id));

      r = manager_add_inhibitor(m, id, &i);
      if (r < 0)
              return r;

      i->what = w;
      i->mode = mm;
      i->pid = pid;
      i->uid = uid;
      i->why = strdup(why);
      i->who = strdup(who);

      if (!i->why || !i->who) {
              r = -ENOMEM12;
              goto fail;
      }

      fifo_fd = inhibitor_create_fifo(i);
      if (fifo_fd < 0) {
              r = fifo_fd;
              goto fail;
      }

      inhibitor_start(i);

      return sd_bus_reply_method_return(message, "h", fifo_fd);

2641fail:
      if (i)
              inhibitor_free(i);

      return r;
2646}

2648const sd_bus_vtable manager_vtable[] = {
      SD_BUS_VTABLE_START(0){ .type = _SD_BUS_VTABLE_START, .flags = 0, .x = { .start = {
 .element_size = sizeof(sd_bus_vtable) }, }, },

      SD_BUS_WRITABLE_PROPERTY("EnableWallMessages", "b", NULL, NULL, offsetof(Manager, enable_wall_messages), 0){ .type = _SD_BUS_VTABLE_WRITABLE_PROPERTY, .flags = 0, .x = {
 .property = { .member = "EnableWallMessages", .signature = "b"
, .get = ((void*)0), .set = ((void*)0), .offset = __builtin_offsetof
(Manager, enable_wall_messages), }, }, },
      SD_BUS_WRITABLE_PROPERTY("WallMessage", "s", NULL, NULL, offsetof(Manager, wall_message), 0){ .type = _SD_BUS_VTABLE_WRITABLE_PROPERTY, .flags = 0, .x = {
 .property = { .member = "WallMessage", .signature = "s", .get
 = ((void*)0), .set = ((void*)0), .offset = __builtin_offsetof
(Manager, wall_message), }, }, },

      SD_BUS_PROPERTY("NAutoVTs", "u", NULL, offsetof(Manager, n_autovts), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "NAutoVTs", .signature = "u"
, .get = ((void*)0), .set = ((void*)0), .offset = __builtin_offsetof
(Manager, n_autovts), }, }, },
      SD_BUS_PROPERTY("KillOnlyUsers", "as", NULL, offsetof(Manager, kill_only_users), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "KillOnlyUsers", .signature =
 "as", .get = ((void*)0), .set = ((void*)0), .offset = __builtin_offsetof
(Manager, kill_only_users), }, }, },
      SD_BUS_PROPERTY("KillExcludeUsers", "as", NULL, offsetof(Manager, kill_exclude_users), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "KillExcludeUsers", .signature
 = "as", .get = ((void*)0), .set = ((void*)0), .offset = __builtin_offsetof
(Manager, kill_exclude_users), }, }, },
      SD_BUS_PROPERTY("KillUserProcesses", "b", NULL, offsetof(Manager, kill_user_processes), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "KillUserProcesses", .signature
 = "b", .get = ((void*)0), .set = ((void*)0), .offset = __builtin_offsetof
(Manager, kill_user_processes), }, }, },
      SD_BUS_PROPERTY("RebootToFirmwareSetup", "b", property_get_reboot_to_firmware_setup, 0, SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "RebootToFirmwareSetup", .signature
 = "b", .get = property_get_reboot_to_firmware_setup, .set = (
(void*)0), .offset = 0, }, }, },
      SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
, .x = { .property = { .member = "IdleHint", .signature = "b"
, .get = property_get_idle_hint, .set = ((void*)0), .offset =
 0, }, }, },
      SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
, .x = { .property = { .member = "IdleSinceHint", .signature =
 "t", .get = property_get_idle_since_hint, .set = ((void*)0),
 .offset = 0, }, }, },
      SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
, .x = { .property = { .member = "IdleSinceHintMonotonic", .signature
 = "t", .get = property_get_idle_since_hint, .set = ((void*)0
), .offset = 0, }, }, },
      SD_BUS_PROPERTY("BlockInhibited", "s", property_get_inhibited, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
, .x = { .property = { .member = "BlockInhibited", .signature
 = "s", .get = property_get_inhibited, .set = ((void*)0), .offset
 = 0, }, }, },
      SD_BUS_PROPERTY("DelayInhibited", "s", property_get_inhibited, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
, .x = { .property = { .member = "DelayInhibited", .signature
 = "s", .get = property_get_inhibited, .set = ((void*)0), .offset
 = 0, }, }, },
      SD_BUS_PROPERTY("InhibitDelayMaxUSec", "t", NULL, offsetof(Manager, inhibit_delay_max), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "InhibitDelayMaxUSec", .signature
 = "t", .get = ((void*)0), .set = ((void*)0), .offset = __builtin_offsetof
(Manager, inhibit_delay_max), }, }, },
      SD_BUS_PROPERTY("HandlePowerKey", "s", property_get_handle_action, offsetof(Manager, handle_power_key), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "HandlePowerKey", .signature
 = "s", .get = property_get_handle_action, .set = ((void*)0),
 .offset = __builtin_offsetof(Manager, handle_power_key), }, }
, },
      SD_BUS_PROPERTY("HandleSuspendKey", "s", property_get_handle_action, offsetof(Manager, handle_suspend_key), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "HandleSuspendKey", .signature
 = "s", .get = property_get_handle_action, .set = ((void*)0),
 .offset = __builtin_offsetof(Manager, handle_suspend_key), }
, }, },
      SD_BUS_PROPERTY("HandleHibernateKey", "s", property_get_handle_action, offsetof(Manager, handle_hibernate_key), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "HandleHibernateKey", .signature
 = "s", .get = property_get_handle_action, .set = ((void*)0),
 .offset = __builtin_offsetof(Manager, handle_hibernate_key),
 }, }, },
      SD_BUS_PROPERTY("HandleLidSwitch", "s", property_get_handle_action, offsetof(Manager, handle_lid_switch), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "HandleLidSwitch", .signature
 = "s", .get = property_get_handle_action, .set = ((void*)0),
 .offset = __builtin_offsetof(Manager, handle_lid_switch), },
 }, },
      SD_BUS_PROPERTY("HandleLidSwitchExternalPower", "s", property_get_handle_action, offsetof(Manager, handle_lid_switch_ep), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "HandleLidSwitchExternalPower"
, .signature = "s", .get = property_get_handle_action, .set =
 ((void*)0), .offset = __builtin_offsetof(Manager, handle_lid_switch_ep
), }, }, },
      SD_BUS_PROPERTY("HandleLidSwitchDocked", "s", property_get_handle_action, offsetof(Manager, handle_lid_switch_docked), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "HandleLidSwitchDocked", .signature
 = "s", .get = property_get_handle_action, .set = ((void*)0),
 .offset = __builtin_offsetof(Manager, handle_lid_switch_docked
), }, }, },
      SD_BUS_PROPERTY("HoldoffTimeoutUSec", "t", NULL, offsetof(Manager, holdoff_timeout_usec), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "HoldoffTimeoutUSec", .signature
 = "t", .get = ((void*)0), .set = ((void*)0), .offset = __builtin_offsetof
(Manager, holdoff_timeout_usec), }, }, },
      SD_BUS_PROPERTY("IdleAction", "s", property_get_handle_action, offsetof(Manager, idle_action), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "IdleAction", .signature = "s"
, .get = property_get_handle_action, .set = ((void*)0), .offset
 = __builtin_offsetof(Manager, idle_action), }, }, },
      SD_BUS_PROPERTY("IdleActionUSec", "t", NULL, offsetof(Manager, idle_action_usec), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "IdleActionUSec", .signature
 = "t", .get = ((void*)0), .set = ((void*)0), .offset = __builtin_offsetof
(Manager, idle_action_usec), }, }, },
      SD_BUS_PROPERTY("PreparingForShutdown", "b", property_get_preparing, 0, 0){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = 0, .x = { .property
 = { .member = "PreparingForShutdown", .signature = "b", .get
 = property_get_preparing, .set = ((void*)0), .offset = 0, },
 }, },
      SD_BUS_PROPERTY("PreparingForSleep", "b", property_get_preparing, 0, 0){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = 0, .x = { .property
 = { .member = "PreparingForSleep", .signature = "b", .get = property_get_preparing
, .set = ((void*)0), .offset = 0, }, }, },
      SD_BUS_PROPERTY("ScheduledShutdown", "(st)", property_get_scheduled_shutdown, 0, 0){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = 0, .x = { .property
 = { .member = "ScheduledShutdown", .signature = "(st)", .get
 = property_get_scheduled_shutdown, .set = ((void*)0), .offset
 = 0, }, }, },
      SD_BUS_PROPERTY("Docked", "b", property_get_docked, 0, 0){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = 0, .x = { .property
 = { .member = "Docked", .signature = "b", .get = property_get_docked
, .set = ((void*)0), .offset = 0, }, }, },
      SD_BUS_PROPERTY("RemoveIPC", "b", bus_property_get_bool, offsetof(Manager, remove_ipc), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "RemoveIPC", .signature = "b"
, .get = bus_property_get_bool, .set = ((void*)0), .offset = __builtin_offsetof
(Manager, remove_ipc), }, }, },
      SD_BUS_PROPERTY("RuntimeDirectorySize", "t", NULL, offsetof(Manager, runtime_dir_size), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "RuntimeDirectorySize", .signature
 = "t", .get = ((void*)0), .set = ((void*)0), .offset = __builtin_offsetof
(Manager, runtime_dir_size), }, }, },
      SD_BUS_PROPERTY("InhibitorsMax", "t", NULL, offsetof(Manager, inhibitors_max), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "InhibitorsMax", .signature =
 "t", .get = ((void*)0), .set = ((void*)0), .offset = __builtin_offsetof
(Manager, inhibitors_max), }, }, },
      SD_BUS_PROPERTY("NCurrentInhibitors", "t", property_get_hashmap_size, offsetof(Manager, inhibitors), 0){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = 0, .x = { .property
 = { .member = "NCurrentInhibitors", .signature = "t", .get =
 property_get_hashmap_size, .set = ((void*)0), .offset = __builtin_offsetof
(Manager, inhibitors), }, }, },
      SD_BUS_PROPERTY("SessionsMax", "t", NULL, offsetof(Manager, sessions_max), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "SessionsMax", .signature = "t"
, .get = ((void*)0), .set = ((void*)0), .offset = __builtin_offsetof
(Manager, sessions_max), }, }, },
      SD_BUS_PROPERTY("NCurrentSessions", "t", property_get_hashmap_size, offsetof(Manager, sessions), 0){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = 0, .x = { .property
 = { .member = "NCurrentSessions", .signature = "t", .get = property_get_hashmap_size
, .set = ((void*)0), .offset = __builtin_offsetof(Manager, sessions
), }, }, },
      SD_BUS_PROPERTY("UserTasksMax", "t", property_get_compat_user_tasks_max, 0, SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
|SD_BUS_VTABLE_HIDDEN, .x = { .property = { .member = "UserTasksMax"
, .signature = "t", .get = property_get_compat_user_tasks_max
, .set = ((void*)0), .offset = 0, }, }, },

      SD_BUS_METHOD("GetSession", "s", "o", method_get_session, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "GetSession", .signature = "s"
, .result = "o", .handler = method_get_session, .offset = 0, }
, }, },
      SD_BUS_METHOD("GetSessionByPID", "u", "o", method_get_session_by_pid, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "GetSessionByPID", .signature =
 "u", .result = "o", .handler = method_get_session_by_pid, .offset
 = 0, }, }, },
      SD_BUS_METHOD("GetUser", "u", "o", method_get_user, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "GetUser", .signature = "u", .
result = "o", .handler = method_get_user, .offset = 0, }, }, },
      SD_BUS_METHOD("GetUserByPID", "u", "o", method_get_user_by_pid, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "GetUserByPID", .signature = "u"
, .result = "o", .handler = method_get_user_by_pid, .offset =
 0, }, }, },
      SD_BUS_METHOD("GetSeat", "s", "o", method_get_seat, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "GetSeat", .signature = "s", .
result = "o", .handler = method_get_seat, .offset = 0, }, }, },
      SD_BUS_METHOD("ListSessions", NULL, "a(susso)", method_list_sessions, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "ListSessions", .signature = (
(void*)0), .result = "a(susso)", .handler = method_list_sessions
, .offset = 0, }, }, },
      SD_BUS_METHOD("ListUsers", NULL, "a(uso)", method_list_users, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "ListUsers", .signature = ((void
*)0), .result = "a(uso)", .handler = method_list_users, .offset
 = 0, }, }, },
      SD_BUS_METHOD("ListSeats", NULL, "a(so)", method_list_seats, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "ListSeats", .signature = ((void
*)0), .result = "a(so)", .handler = method_list_seats, .offset
 = 0, }, }, },
      SD_BUS_METHOD("ListInhibitors", NULL, "a(ssssuu)", method_list_inhibitors, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "ListInhibitors", .signature =
 ((void*)0), .result = "a(ssssuu)", .handler = method_list_inhibitors
, .offset = 0, }, }, },
      SD_BUS_METHOD("CreateSession", "uusssssussbssa(sv)", "soshusub", method_create_session, 0){ .type = _SD_BUS_VTABLE_METHOD, .flags = 0, .x = { .method =
 { .member = "CreateSession", .signature = "uusssssussbssa(sv)"
, .result = "soshusub", .handler = method_create_session, .offset
 = 0, }, }, },
      SD_BUS_METHOD("ReleaseSession", "s", NULL, method_release_session, 0){ .type = _SD_BUS_VTABLE_METHOD, .flags = 0, .x = { .method =
 { .member = "ReleaseSession", .signature = "s", .result = ((
void*)0), .handler = method_release_session, .offset = 0, }, }
, },
      SD_BUS_METHOD("ActivateSession", "s", NULL, method_activate_session, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "ActivateSession", .signature =
 "s", .result = ((void*)0), .handler = method_activate_session
, .offset = 0, }, }, },
      SD_BUS_METHOD("ActivateSessionOnSeat", "ss", NULL, method_activate_session_on_seat, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "ActivateSessionOnSeat", .signature
 = "ss", .result = ((void*)0), .handler = method_activate_session_on_seat
, .offset = 0, }, }, },
      SD_BUS_METHOD("LockSession", "s", NULL, method_lock_session, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "LockSession", .signature = "s"
, .result = ((void*)0), .handler = method_lock_session, .offset
 = 0, }, }, },
      SD_BUS_METHOD("UnlockSession", "s", NULL, method_lock_session, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "UnlockSession", .signature = "s"
, .result = ((void*)0), .handler = method_lock_session, .offset
 = 0, }, }, },
      SD_BUS_METHOD("LockSessions", NULL, NULL, method_lock_sessions, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "LockSessions", .signature = (
(void*)0), .result = ((void*)0), .handler = method_lock_sessions
, .offset = 0, }, }, },
      SD_BUS_METHOD("UnlockSessions", NULL, NULL, method_lock_sessions, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "UnlockSessions", .signature =
 ((void*)0), .result = ((void*)0), .handler = method_lock_sessions
, .offset = 0, }, }, },
      SD_BUS_METHOD("KillSession", "ssi", NULL, method_kill_session, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "KillSession", .signature = "ssi"
, .result = ((void*)0), .handler = method_kill_session, .offset
 = 0, }, }, },
      SD_BUS_METHOD("KillUser", "ui", NULL, method_kill_user, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "KillUser", .signature = "ui",
 .result = ((void*)0), .handler = method_kill_user, .offset =
 0, }, }, },
      SD_BUS_METHOD("TerminateSession", "s", NULL, method_terminate_session, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "TerminateSession", .signature
 = "s", .result = ((void*)0), .handler = method_terminate_session
, .offset = 0, }, }, },
      SD_BUS_METHOD("TerminateUser", "u", NULL, method_terminate_user, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "TerminateUser", .signature = "u"
, .result = ((void*)0), .handler = method_terminate_user, .offset
 = 0, }, }, },
      SD_BUS_METHOD("TerminateSeat", "s", NULL, method_terminate_seat, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "TerminateSeat", .signature = "s"
, .result = ((void*)0), .handler = method_terminate_seat, .offset
 = 0, }, }, },
      SD_BUS_METHOD("SetUserLinger", "ubb", NULL, method_set_user_linger, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "SetUserLinger", .signature = "ubb"
, .result = ((void*)0), .handler = method_set_user_linger, .offset
 = 0, }, }, },
      SD_BUS_METHOD("AttachDevice", "ssb", NULL, method_attach_device, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "AttachDevice", .signature = "ssb"
, .result = ((void*)0), .handler = method_attach_device, .offset
 = 0, }, }, },
      SD_BUS_METHOD("FlushDevices", "b", NULL, method_flush_devices, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "FlushDevices", .signature = "b"
, .result = ((void*)0), .handler = method_flush_devices, .offset
 = 0, }, }, },
      SD_BUS_METHOD("PowerOff", "b", NULL, method_poweroff, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "PowerOff", .signature = "b", .
result = ((void*)0), .handler = method_poweroff, .offset = 0,
 }, }, },
      SD_BUS_METHOD("Reboot", "b", NULL, method_reboot, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "Reboot", .signature = "b", .result
 = ((void*)0), .handler = method_reboot, .offset = 0, }, }, },
      SD_BUS_METHOD("Halt", "b", NULL, method_halt, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "Halt", .signature = "b", .result
 = ((void*)0), .handler = method_halt, .offset = 0, }, }, },
      SD_BUS_METHOD("Suspend", "b", NULL, method_suspend, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "Suspend", .signature = "b", .
result = ((void*)0), .handler = method_suspend, .offset = 0, }
, }, },
      SD_BUS_METHOD("Hibernate", "b", NULL, method_hibernate, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "Hibernate", .signature = "b",
 .result = ((void*)0), .handler = method_hibernate, .offset =
 0, }, }, },
      SD_BUS_METHOD("HybridSleep", "b", NULL, method_hybrid_sleep, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "HybridSleep", .signature = "b"
, .result = ((void*)0), .handler = method_hybrid_sleep, .offset
 = 0, }, }, },
      SD_BUS_METHOD("SuspendThenHibernate", "b", NULL, method_suspend_then_hibernate, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "SuspendThenHibernate", .signature
 = "b", .result = ((void*)0), .handler = method_suspend_then_hibernate
, .offset = 0, }, }, },
      SD_BUS_METHOD("CanPowerOff", NULL, "s", method_can_poweroff, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "CanPowerOff", .signature = ((
void*)0), .result = "s", .handler = method_can_poweroff, .offset
 = 0, }, }, },
      SD_BUS_METHOD("CanReboot", NULL, "s", method_can_reboot, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "CanReboot", .signature = ((void
*)0), .result = "s", .handler = method_can_reboot, .offset = 0
, }, }, },
      SD_BUS_METHOD("CanHalt", NULL, "s", method_can_halt, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "CanHalt", .signature = ((void
*)0), .result = "s", .handler = method_can_halt, .offset = 0,
 }, }, },
      SD_BUS_METHOD("CanSuspend", NULL, "s", method_can_suspend, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "CanSuspend", .signature = ((void
*)0), .result = "s", .handler = method_can_suspend, .offset =
 0, }, }, },
      SD_BUS_METHOD("CanHibernate", NULL, "s", method_can_hibernate, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "CanHibernate", .signature = (
(void*)0), .result = "s", .handler = method_can_hibernate, .offset
 = 0, }, }, },
      SD_BUS_METHOD("CanHybridSleep", NULL, "s", method_can_hybrid_sleep, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "CanHybridSleep", .signature =
 ((void*)0), .result = "s", .handler = method_can_hybrid_sleep
, .offset = 0, }, }, },
      SD_BUS_METHOD("CanSuspendThenHibernate", NULL, "s", method_can_suspend_then_hibernate, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "CanSuspendThenHibernate", .signature
 = ((void*)0), .result = "s", .handler = method_can_suspend_then_hibernate
, .offset = 0, }, }, },
      SD_BUS_METHOD("ScheduleShutdown", "st", NULL, method_schedule_shutdown, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "ScheduleShutdown", .signature
 = "st", .result = ((void*)0), .handler = method_schedule_shutdown
, .offset = 0, }, }, },
      SD_BUS_METHOD("CancelScheduledShutdown", NULL, "b", method_cancel_scheduled_shutdown, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "CancelScheduledShutdown", .signature
 = ((void*)0), .result = "b", .handler = method_cancel_scheduled_shutdown
, .offset = 0, }, }, },
      SD_BUS_METHOD("Inhibit", "ssss", "h", method_inhibit, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "Inhibit", .signature = "ssss"
, .result = "h", .handler = method_inhibit, .offset = 0, }, }
, },
      SD_BUS_METHOD("CanRebootToFirmwareSetup", NULL, "s", method_can_reboot_to_firmware_setup, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "CanRebootToFirmwareSetup", .signature
 = ((void*)0), .result = "s", .handler = method_can_reboot_to_firmware_setup
, .offset = 0, }, }, },
      SD_BUS_METHOD("SetRebootToFirmwareSetup", "b", NULL, method_set_reboot_to_firmware_setup, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "SetRebootToFirmwareSetup", .signature
 = "b", .result = ((void*)0), .handler = method_set_reboot_to_firmware_setup
, .offset = 0, }, }, },
      SD_BUS_METHOD("SetWallMessage", "sb", NULL, method_set_wall_message, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "SetWallMessage", .signature =
 "sb", .result = ((void*)0), .handler = method_set_wall_message
, .offset = 0, }, }, },

      SD_BUS_SIGNAL("SessionNew", "so", 0){ .type = _SD_BUS_VTABLE_SIGNAL, .flags = 0, .x = { .signal =
 { .member = "SessionNew", .signature = "so", }, }, },
      SD_BUS_SIGNAL("SessionRemoved", "so", 0){ .type = _SD_BUS_VTABLE_SIGNAL, .flags = 0, .x = { .signal =
 { .member = "SessionRemoved", .signature = "so", }, }, },
      SD_BUS_SIGNAL("UserNew", "uo", 0){ .type = _SD_BUS_VTABLE_SIGNAL, .flags = 0, .x = { .signal =
 { .member = "UserNew", .signature = "uo", }, }, },
      SD_BUS_SIGNAL("UserRemoved", "uo", 0){ .type = _SD_BUS_VTABLE_SIGNAL, .flags = 0, .x = { .signal =
 { .member = "UserRemoved", .signature = "uo", }, }, },
      SD_BUS_SIGNAL("SeatNew", "so", 0){ .type = _SD_BUS_VTABLE_SIGNAL, .flags = 0, .x = { .signal =
 { .member = "SeatNew", .signature = "so", }, }, },
      SD_BUS_SIGNAL("SeatRemoved", "so", 0){ .type = _SD_BUS_VTABLE_SIGNAL, .flags = 0, .x = { .signal =
 { .member = "SeatRemoved", .signature = "so", }, }, },
      SD_BUS_SIGNAL("PrepareForShutdown", "b", 0){ .type = _SD_BUS_VTABLE_SIGNAL, .flags = 0, .x = { .signal =
 { .member = "PrepareForShutdown", .signature = "b", }, }, },
      SD_BUS_SIGNAL("PrepareForSleep", "b", 0){ .type = _SD_BUS_VTABLE_SIGNAL, .flags = 0, .x = { .signal =
 { .member = "PrepareForSleep", .signature = "b", }, }, },

      SD_BUS_VTABLE_END{ .type = _SD_BUS_VTABLE_END, .flags = 0, .x = { { 0 } }, }
2742};

2744static int session_jobs_reply(Session *s, const char *unit, const char *result) {
      int r = 0;

      assert(s)do { if ((__builtin_expect(!!(!(s)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("s"), "../src/login/logind-dbus.c", 2747
, __PRETTY_FUNCTION__); } while (0);
      assert(unit)do { if ((__builtin_expect(!!(!(unit)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("unit"), "../src/login/logind-dbus.c", 2748
, __PRETTY_FUNCTION__); } while (0);

      if (!s->started)
              return r;

      if (streq(result, "done")(strcmp((result),("done")) == 0))
              r = session_send_create_reply(s, NULL((void*)0));
      else {
              _cleanup_(sd_bus_error_free)__attribute__((cleanup(sd_bus_error_free))) sd_bus_error e = SD_BUS_ERROR_NULL((const sd_bus_error) {(((void*)0)), (((void*)0)), 0});

              sd_bus_error_setf(&e, BUS_ERROR_JOB_FAILED"org.freedesktop.systemd1.JobFailed", "Start job for unit %s failed with '%s'", unit, result);
              r = session_send_create_reply(s, &e);
      }

      return r;
2763}

2765int match_job_removed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      const char *path, *result, *unit;
      Manager *m = userdata;
      Session *session;
      uint32_t id;
      User *user;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 2773, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 2774
, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "uoss", &id, &path, &unit, &result);
      if (r < 0) {
              bus_log_parse_error(r);
              return 0;
      }

      if (m->action_job && streq(m->action_job, path)(strcmp((m->action_job),(path)) == 0)) {
              log_info("Operation '%s' finished.", inhibit_what_to_string(m->action_what))({ int _level = (((6))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 2783, __func__, "Operation '%s' finished."
, inhibit_what_to_string(m->action_what)) : -abs(_e); });

              /* Tell people that they now may take a lock again */
              (void) send_prepare_for(m, m->action_what, false0);

              m->action_job = mfree(m->action_job);
              m->action_unit = NULL((void*)0);
              m->action_what = 0;
              return 0;
      }

      session = hashmap_get(m->session_units, unit);
      if (session && streq_ptr(path, session->scope_job)) {
              session->scope_job = mfree(session->scope_job);
              session_jobs_reply(session, unit, result);

              session_save(session);
              user_save(session->user);
              session_add_to_gc_queue(session);
      }

      user = hashmap_get(m->user_units, unit);
      if (user &&
          (streq_ptr(path, user->service_job) ||
           streq_ptr(path, user->slice_job))) {

              if (streq_ptr(path, user->service_job))
                      user->service_job = mfree(user->service_job);

              if (streq_ptr(path, user->slice_job))
                      user->slice_job = mfree(user->slice_job);

              LIST_FOREACH(sessions_by_user, session, user->sessions)for ((session) = (user->sessions); (session); (session) = (
session)->sessions_by_user_next)
                      session_jobs_reply(session, unit, result);

              user_save(user);
              user_add_to_gc_queue(user);
      }

      return 0;
2823}

2825int match_unit_removed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      const char *path, *unit;
      Manager *m = userdata;
      Session *session;
      User *user;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 2832, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 2833
, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "so", &unit, &path);
      if (r < 0) {
              bus_log_parse_error(r);
              return 0;
      }

      session = hashmap_get(m->session_units, unit);
      if (session)
              session_add_to_gc_queue(session);

      user = hashmap_get(m->user_units, unit);
      if (user)
              user_add_to_gc_queue(user);

      return 0;
2850}

2852int match_properties_changed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      _cleanup_free___attribute__((cleanup(freep))) char *unit = NULL((void*)0);
      Manager *m = userdata;
      const char *path;
      Session *session;
      User *user;
      int r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 2860, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 2861
, __PRETTY_FUNCTION__); } while (0);

      path = sd_bus_message_get_path(message);
      if (!path)
              return 0;

      r = unit_name_from_dbus_path(path, &unit);
      if (r == -EINVAL22) /* not a unit */
              return 0;
      if (r < 0) {
              log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/login/logind-dbus.c"
, 2871, __func__);
              return 0;
      }

      session = hashmap_get(m->session_units, unit);
      if (session)
              session_add_to_gc_queue(session);

      user = hashmap_get(m->user_units, unit);
      if (user)
              user_add_to_gc_queue(user);

      return 0;
2884}

2886int match_reloading(sd_bus_message *message, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;
      Session *session;
      Iterator i;
      int b, r;

      assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/login/logind-dbus.c"
, 2892, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/login/logind-dbus.c", 2893
, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_read(message, "b", &b);
      if (r < 0) {
              bus_log_parse_error(r);
              return 0;
      }

      if (b)
              return 0;

      /* systemd finished reloading, let's recheck all our sessions */
      log_debug("System manager has been reloaded, rechecking sessions...")({ int _level = (((7))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/login/logind-dbus.c", 2905, __func__, "System manager has been reloaded, rechecking sessions..."
) : -abs(_e); });

      HASHMAP_FOREACH(session, m->sessions, i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((m->sessions), &
(i), (void**)&(session), ((void*)0)); )
              session_add_to_gc_queue(session);

      return 0;
2911}

2913int manager_send_changed(Manager *manager, const char *property, ...) {
      char **l;

      assert(manager)do { if ((__builtin_expect(!!(!(manager)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("manager"), "../src/login/logind-dbus.c"
, 2916, __PRETTY_FUNCTION__); } while (0);

      l = strv_from_stdarg_alloca(property)({ char **_l; if (!property) _l = (char**) &property; else
 { size_t _n; va_list _ap; _n = 1; __builtin_va_start(_ap, property
); while (__builtin_va_arg(_ap, char*)) _n++; __builtin_va_end
(_ap); _l = ({ do { if ((__builtin_expect(!!(!(!size_multiply_overflow
(sizeof(char*), _n+1))),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("!size_multiply_overflow(sizeof(char*), _n+1)"), "../src/login/logind-dbus.c"
, 2918, __PRETTY_FUNCTION__); } while (0); (char**) __builtin_alloca
 (sizeof(char*)*(_n+1)); }); _l[_n = 0] = (char*) property; __builtin_va_start
(_ap, property); for (;;) { _l[++_n] = __builtin_va_arg(_ap, char
*); if (!_l[_n]) break; } __builtin_va_end(_ap); } _l; });

      return sd_bus_emit_properties_changed_strv(
                      manager->bus,
                      "/org/freedesktop/login1",
                      "org.freedesktop.login1.Manager",
                      l);
2925}

2927static int strdup_job(sd_bus_message *reply, char **job) {
      const char *j;
      char *copy;
      int r;

      r = sd_bus_message_read(reply, "o", &j);
      if (r < 0)
              return r;

      copy = strdup(j);
      if (!copy)
              return -ENOMEM12;

      *job = copy;
      return 1;
2942}

2944int manager_start_scope(
              Manager *manager,
              const char *scope,
              pid_t pid,
              const char *slice,
              const char *description,
              const char *after,
              const char *after2,
              sd_bus_message *more_properties,
              sd_bus_error *error,
              char **job) {

      _cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *m = NULL((void*)0), *reply = NULL((void*)0);
      int r;

      assert(manager)do { if ((__builtin_expect(!!(!(manager)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("manager"), "../src/login/logind-dbus.c"
, 2959, __PRETTY_FUNCTION__); } while (0);
      assert(scope)do { if ((__builtin_expect(!!(!(scope)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("scope"), "../src/login/logind-dbus.c", 2960
, __PRETTY_FUNCTION__); } while (0);
      assert(pid > 1)do { if ((__builtin_expect(!!(!(pid > 1)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("pid > 1"), "../src/login/logind-dbus.c"
, 2961, __PRETTY_FUNCTION__); } while (0);
      assert(job)do { if ((__builtin_expect(!!(!(job)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("job"), "../src/login/logind-dbus.c", 2962
, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_new_method_call(
                      manager->bus,
                      &m,
                      "org.freedesktop.systemd1",
                      "/org/freedesktop/systemd1",
                      "org.freedesktop.systemd1.Manager",
                      "StartTransientUnit");
      if (r < 0)
              return r;

      r = sd_bus_message_append(m, "ss", strempty(scope), "fail");
      if (r < 0)
              return r;

      r = sd_bus_message_open_container(m, 'a', "(sv)");
      if (r < 0)
              return r;

      if (!isempty(slice)) {
              r = sd_bus_message_append(m, "(sv)", "Slice", "s", slice);
              if (r < 0)
                      return r;
      }

      if (!isempty(description)) {
              r = sd_bus_message_append(m, "(sv)", "Description", "s", description);
              if (r < 0)
                      return r;
      }

      if (!isempty(after)) {
              r = sd_bus_message_append(m, "(sv)", "After", "as", 1, after);
              if (r < 0)
                      return r;
      }

      if (!isempty(after2)) {
              r = sd_bus_message_append(m, "(sv)", "After", "as", 1, after2);
              if (r < 0)
                      return r;
      }

      /* Make sure that the session shells are terminated with SIGHUP since bash and friends tend to ignore
       * SIGTERM */
      r = sd_bus_message_append(m, "(sv)", "SendSIGHUP", "b", true1);
      if (r < 0)
              return r;

      r = sd_bus_message_append(m, "(sv)", "PIDs", "au", 1, pid);
      if (r < 0)
              return r;

      /* disable TasksMax= for the session scope, rely on the slice setting for it */
      r = sd_bus_message_append(m, "(sv)", "TasksMax", "t", (uint64_t)-1);
      if (r < 0)
              return bus_log_create_error(r);

      if (more_properties) {
              /* If TasksMax also appears here, it will overwrite the default value set above */
              r = sd_bus_message_copy(m, more_properties, true1);
              if (r < 0)
                      return r;
      }

      r = sd_bus_message_close_container(m);
      if (r < 0)
              return r;

      r = sd_bus_message_append(m, "a(sa(sv))", 0);
      if (r < 0)
              return r;

      r = sd_bus_call(manager->bus, m, 0, error, &reply);
      if (r < 0)
              return r;

      return strdup_job(reply, job);
3041}

3043int manager_start_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job) {
      _cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *reply = NULL((void*)0);
      int r;

      assert(manager)do { if ((__builtin_expect(!!(!(manager)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("manager"), "../src/login/logind-dbus.c"
, 3047, __PRETTY_FUNCTION__); } while (0);
      assert(unit)do { if ((__builtin_expect(!!(!(unit)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("unit"), "../src/login/logind-dbus.c", 3048
, __PRETTY_FUNCTION__); } while (0);
      assert(job)do { if ((__builtin_expect(!!(!(job)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("job"), "../src/login/logind-dbus.c", 3049
, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_call_method(
                      manager->bus,
                      "org.freedesktop.systemd1",
                      "/org/freedesktop/systemd1",
                      "org.freedesktop.systemd1.Manager",
                      "StartUnit",
                      error,
                      &reply,
                      "ss", unit, "replace");
      if (r < 0)
              return r;

      return strdup_job(reply, job);
3064}

3066int manager_stop_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job) {
      _cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *reply = NULL((void*)0);
      int r;

      assert(manager)do { if ((__builtin_expect(!!(!(manager)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("manager"), "../src/login/logind-dbus.c"
, 3070, __PRETTY_FUNCTION__); } while (0);
      assert(unit)do { if ((__builtin_expect(!!(!(unit)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("unit"), "../src/login/logind-dbus.c", 3071
, __PRETTY_FUNCTION__); } while (0);
      assert(job)do { if ((__builtin_expect(!!(!(job)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("job"), "../src/login/logind-dbus.c", 3072
, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_call_method(
                      manager->bus,
                      "org.freedesktop.systemd1",
                      "/org/freedesktop/systemd1",
                      "org.freedesktop.systemd1.Manager",
                      "StopUnit",
                      error,
                      &reply,
                      "ss", unit, "fail");
      if (r < 0) {
              if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT"org.freedesktop.systemd1.NoSuchUnit") ||
                  sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED"org.freedesktop.systemd1.LoadFailed")) {

                      *job = NULL((void*)0);
                      sd_bus_error_free(error);
                      return 0;
              }

              return r;
      }

      return strdup_job(reply, job);
3096}

3098int manager_abandon_scope(Manager *manager, const char *scope, sd_bus_error *error) {
      _cleanup_free___attribute__((cleanup(freep))) char *path = NULL((void*)0);
      int r;

      assert(manager)do { if ((__builtin_expect(!!(!(manager)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("manager"), "../src/login/logind-dbus.c"
, 3102, __PRETTY_FUNCTION__); } while (0);
      assert(scope)do { if ((__builtin_expect(!!(!(scope)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("scope"), "../src/login/logind-dbus.c", 3103
, __PRETTY_FUNCTION__); } while (0);

      path = unit_dbus_path_from_name(scope);
      if (!path)
              return -ENOMEM12;

      r = sd_bus_call_method(
                      manager->bus,
                      "org.freedesktop.systemd1",
                      path,
                      "org.freedesktop.systemd1.Scope",
                      "Abandon",
                      error,
                      NULL((void*)0),
                      NULL((void*)0));
      if (r < 0) {
              if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT"org.freedesktop.systemd1.NoSuchUnit") ||
                  sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED"org.freedesktop.systemd1.LoadFailed") ||
                  sd_bus_error_has_name(error, BUS_ERROR_SCOPE_NOT_RUNNING"org.freedesktop.systemd1.ScopeNotRunning")) {
                      sd_bus_error_free(error);
                      return 0;
              }

              return r;
      }

      return 1;
3130}

3132int manager_kill_unit(Manager *manager, const char *unit, KillWho who, int signo, sd_bus_error *error) {
      assert(manager)do { if ((__builtin_expect(!!(!(manager)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("manager"), "../src/login/logind-dbus.c"
, 3133, __PRETTY_FUNCTION__); } while (0);
      assert(unit)do { if ((__builtin_expect(!!(!(unit)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("unit"), "../src/login/logind-dbus.c", 3134
, __PRETTY_FUNCTION__); } while (0);

      return sd_bus_call_method(
                      manager->bus,
                      "org.freedesktop.systemd1",
                      "/org/freedesktop/systemd1",
                      "org.freedesktop.systemd1.Manager",
                      "KillUnit",
                      error,
                      NULL((void*)0),
                      "ssi", unit, who == KILL_LEADER ? "main" : "all", signo);
3145}

3147int manager_unit_is_active(Manager *manager, const char *unit) {
      _cleanup_(sd_bus_error_free)__attribute__((cleanup(sd_bus_error_free))) sd_bus_error error = SD_BUS_ERROR_NULL((const sd_bus_error) {(((void*)0)), (((void*)0)), 0});
      _cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *reply = NULL((void*)0);
      _cleanup_free___attribute__((cleanup(freep))) char *path = NULL((void*)0);
      const char *state;
      int r;

      assert(manager)do { if ((__builtin_expect(!!(!(manager)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("manager"), "../src/login/logind-dbus.c"
, 3154, __PRETTY_FUNCTION__); } while (0);
      assert(unit)do { if ((__builtin_expect(!!(!(unit)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("unit"), "../src/login/logind-dbus.c", 3155
, __PRETTY_FUNCTION__); } while (0);

      path = unit_dbus_path_from_name(unit);
      if (!path)
              return -ENOMEM12;

      r = sd_bus_get_property(
                      manager->bus,
                      "org.freedesktop.systemd1",
                      path,
                      "org.freedesktop.systemd1.Unit",
                      "ActiveState",
                      &error,
                      &reply,
                      "s");
      if (r < 0) {
              /* systemd might have droppped off momentarily, let's
               * not make this an error */
              if (sd_bus_error_has_name(&error, SD_BUS_ERROR_NO_REPLY"org.freedesktop.DBus.Error.NoReply") ||
                  sd_bus_error_has_name(&error, SD_BUS_ERROR_DISCONNECTED"org.freedesktop.DBus.Error.Disconnected"))
                      return true1;

              /* If the unit is already unloaded then it's not
               * active */
              if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_UNIT"org.freedesktop.systemd1.NoSuchUnit") ||
                  sd_bus_error_has_name(&error, BUS_ERROR_LOAD_FAILED"org.freedesktop.systemd1.LoadFailed"))
                      return false0;

              return r;
      }

      r = sd_bus_message_read(reply, "s", &state);
      if (r < 0)
              return -EINVAL22;

      return !streq(state, "inactive")(strcmp((state),("inactive")) == 0) && !streq(state, "failed")(strcmp((state),("failed")) == 0);
3191}

3193int manager_job_is_active(Manager *manager, const char *path) {
      _cleanup_(sd_bus_error_free)__attribute__((cleanup(sd_bus_error_free))) sd_bus_error error = SD_BUS_ERROR_NULL((const sd_bus_error) {(((void*)0)), (((void*)0)), 0});
      _cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *reply = NULL((void*)0);
      int r;

      assert(manager)do { if ((__builtin_expect(!!(!(manager)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("manager"), "../src/login/logind-dbus.c"
, 3198, __PRETTY_FUNCTION__); } while (0);
      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/login/logind-dbus.c", 3199
, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_get_property(
                      manager->bus,
                      "org.freedesktop.systemd1",
                      path,
                      "org.freedesktop.systemd1.Job",
                      "State",
                      &error,
                      &reply,
                      "s");
      if (r < 0) {
              if (sd_bus_error_has_name(&error, SD_BUS_ERROR_NO_REPLY"org.freedesktop.DBus.Error.NoReply") ||
                  sd_bus_error_has_name(&error, SD_BUS_ERROR_DISCONNECTED"org.freedesktop.DBus.Error.Disconnected"))
                      return true1;

              if (sd_bus_error_has_name(&error, SD_BUS_ERROR_UNKNOWN_OBJECT"org.freedesktop.DBus.Error.UnknownObject"))
                      return false0;

              return r;
      }

      /* We don't actually care about the state really. The fact
       * that we could read the job state is enough for us */

      return true1;
3225}