../src/import/importd.c

Bug Summary

File:	build-scan/../src/import/importd.c
Warning:	line 1060, column 33 Potential leak of memory pointed to by 'l'
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 importd.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 static -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 systemd-importd.p -I . -I .. -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/login -I ../src/login -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 -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/import/importd.c
1/* SPDX-License-Identifier: LGPL-2.1+ */

3#include <sys/prctl.h>
4#include <sys/wait.h>

6#include "sd-bus.h"

8#include "alloc-util.h"
9#include "bus-common-errors.h"
10#include "bus-util.h"
11#include "def.h"
12#include "fd-util.h"
13#include "hostname-util.h"
14#include "import-util.h"
15#include "machine-pool.h"
16#include "missing.h"
17#include "mkdir.h"
18#include "parse-util.h"
19#include "path-util.h"
20#include "process-util.h"
21#include "signal-util.h"
22#include "socket-util.h"
23#include "string-table.h"
24#include "strv.h"
25#include "syslog-util.h"
26#include "user-util.h"
27#include "util.h"
28#include "web-util.h"

30typedef struct Transfer Transfer;
31typedef struct Manager Manager;

33typedef enum TransferType {
      TRANSFER_IMPORT_TAR,
      TRANSFER_IMPORT_RAW,
      TRANSFER_EXPORT_TAR,
      TRANSFER_EXPORT_RAW,
      TRANSFER_PULL_TAR,
      TRANSFER_PULL_RAW,
      _TRANSFER_TYPE_MAX,
      _TRANSFER_TYPE_INVALID = -1,
42} TransferType;

44struct Transfer {
      Manager *manager;

      uint32_t id;
      char *object_path;

      TransferType type;
      ImportVerify verify;

      char *remote;
      char *local;
      bool_Bool force_local;
      bool_Bool read_only;

      char *format;

      pid_t pid;

      int log_fd;

      char log_message[LINE_MAX2048];
      size_t log_message_size;

      sd_event_source *pid_event_source;
      sd_event_source *log_event_source;

      unsigned n_canceled;
      unsigned progress_percent;

      int stdin_fd;
      int stdout_fd;
75};

77struct Manager {
      sd_event *event;
      sd_bus *bus;

      uint32_t current_transfer_id;
      Hashmap *transfers;

      Hashmap *polkit_registry;

      int notify_fd;

      sd_event_source *notify_event_source;
89};

91#define TRANSFERS_MAX64 64

93static const char* const transfer_type_table[_TRANSFER_TYPE_MAX] = {
      [TRANSFER_IMPORT_TAR] = "import-tar",
      [TRANSFER_IMPORT_RAW] = "import-raw",
      [TRANSFER_EXPORT_TAR] = "export-tar",
      [TRANSFER_EXPORT_RAW] = "export-raw",
      [TRANSFER_PULL_TAR] = "pull-tar",
      [TRANSFER_PULL_RAW] = "pull-raw",
100};

102DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(transfer_type, TransferType)static const char *transfer_type_to_string(TransferType i) { if
 (i < 0 || i >= (TransferType) __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(transfer_type_table), typeof
(&*(transfer_type_table))), sizeof(transfer_type_table)/sizeof
((transfer_type_table)[0]), ((void)0)))) return ((void*)0); return
 transfer_type_table[i]; };

104static Transfer *transfer_unref(Transfer *t) {
      if (!t)
              return NULL((void*)0);

      if (t->manager)
              hashmap_remove(t->manager->transfers, UINT32_TO_PTR(t->id)((void *) ((uintptr_t) (t->id))));

      sd_event_source_unref(t->pid_event_source);
      sd_event_source_unref(t->log_event_source);

      free(t->remote);
      free(t->local);
      free(t->format);
      free(t->object_path);

      if (t->pid > 0) {
              (void) kill_and_sigcont(t->pid, SIGKILL9);
              (void) wait_for_terminate(t->pid, NULL((void*)0));
      }

      safe_close(t->log_fd);
      safe_close(t->stdin_fd);
      safe_close(t->stdout_fd);

      return mfree(t);
129}

131DEFINE_TRIVIAL_CLEANUP_FUNC(Transfer*, transfer_unref)static inline void transfer_unrefp(Transfer* *p) { if (*p) transfer_unref
(*p); };

133static int transfer_new(Manager *m, Transfer **ret) {
      _cleanup_(transfer_unrefp)__attribute__((cleanup(transfer_unrefp))) Transfer *t = NULL((void*)0);
      uint32_t id;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/import/importd.c", 138, __PRETTY_FUNCTION__
); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/import/importd.c", 139, __PRETTY_FUNCTION__
); } while (0);

      if (hashmap_size(m->transfers) >= TRANSFERS_MAX64)
              return -E2BIG7;

      r = hashmap_ensure_allocated(&m->transfers, &trivial_hash_ops)internal_hashmap_ensure_allocated(&m->transfers, &
trivial_hash_ops );
      if (r < 0)
              return r;

      t = new0(Transfer, 1)((Transfer*) calloc((1), sizeof(Transfer)));
      if (!t)
              return -ENOMEM12;

      t->type = _TRANSFER_TYPE_INVALID;
      t->log_fd = -1;
      t->stdin_fd = -1;
      t->stdout_fd = -1;
      t->verify = _IMPORT_VERIFY_INVALID;

      id = m->current_transfer_id + 1;

      if (asprintf(&t->object_path, "/org/freedesktop/import1/transfer/_%" PRIu32"u", id) < 0)
              return -ENOMEM12;

      r = hashmap_put(m->transfers, UINT32_TO_PTR(id)((void *) ((uintptr_t) (id))), t);
      if (r < 0)
              return r;

      m->current_transfer_id = id;

      t->manager = m;
      t->id = id;

      *ret = TAKE_PTR(t)({ typeof(t) _ptr_ = (t); (t) = ((void*)0); _ptr_; });

      return 0;
175}

177static void transfer_send_log_line(Transfer *t, const char *line) {
      int r, priority = LOG_INFO6;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/import/importd.c", 180, __PRETTY_FUNCTION__
); } while (0);
      assert(line)do { if ((__builtin_expect(!!(!(line)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("line"), "../src/import/importd.c", 181,
 __PRETTY_FUNCTION__); } while (0);

      syslog_parse_priority(&line, &priority, true1);

      log_full(priority, "(transfer%" PRIu32 ") %s", t->id, line)({ int _level = (((priority))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/import/importd.c", 185, __func__, "(transfer%" "u" ") %s"
, t->id, line) : -abs(_e); });

      r = sd_bus_emit_signal(
                      t->manager->bus,
                      t->object_path,
                      "org.freedesktop.import1.Transfer",
                      "LogMessage",
                      "us",
                      priority,
                      line);
      if (r < 0)
              log_error_errno(r, "Cannot emit message: %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/import/importd.c", 196, __func__, "Cannot emit message: %m"
) : -abs(_e); });
}

199static void transfer_send_logs(Transfer *t, bool_Bool flush) {
      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/import/importd.c", 200, __PRETTY_FUNCTION__
); } while (0);

      /* Try to send out all log messages, if we can. But if we
       * can't we remove the messages from the buffer, but don't
       * fail */

      while (t->log_message_size > 0) {
              _cleanup_free___attribute__((cleanup(freep))) char *n = NULL((void*)0);
              char *e;

              if (t->log_message_size >= sizeof(t->log_message))
                      e = t->log_message + sizeof(t->log_message);
              else {
                      char *a, *b;

                      a = memchr(t->log_message, 0, t->log_message_size);
                      b = memchr(t->log_message, '\n', t->log_message_size);

                      if (a && b)
                              e = a < b ? a : b;
                      else if (a)
                              e = a;
                      else
                              e = b;
              }

              if (!e) {
                      if (!flush)
                              return;

                      e = t->log_message + t->log_message_size;
              }

              n = strndup(t->log_message, e - t->log_message);

              /* Skip over NUL and newlines */
              while (e < t->log_message + t->log_message_size && (*e == 0 || *e == '\n'))
                      e++;

              memmove(t->log_message, e, t->log_message + sizeof(t->log_message) - e);
              t->log_message_size -= e - t->log_message;

              if (!n) {
                      log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/import/importd.c"
, 243, __func__);
                      continue;
              }

              if (isempty(n))
                      continue;

              transfer_send_log_line(t, n);
      }
252}

254static int transfer_finalize(Transfer *t, bool_Bool success) {
      int r;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/import/importd.c", 257, __PRETTY_FUNCTION__
); } while (0);

      transfer_send_logs(t, true1);

      r = sd_bus_emit_signal(
                      t->manager->bus,
                      "/org/freedesktop/import1",
                      "org.freedesktop.import1.Manager",
                      "TransferRemoved",
                      "uos",
                      t->id,
                      t->object_path,
                      success ? "done" :
                      t->n_canceled > 0 ? "canceled" : "failed");

      if (r < 0)
              log_error_errno(r, "Cannot emit message: %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/import/importd.c", 273, __func__, "Cannot emit message: %m"
) : -abs(_e); });

      transfer_unref(t);
      return 0;
277}

279static int transfer_cancel(Transfer *t) {
      int r;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/import/importd.c", 282, __PRETTY_FUNCTION__
); } while (0);

      r = kill_and_sigcont(t->pid, t->n_canceled < 3 ? SIGTERM15 : SIGKILL9);
      if (r < 0)
              return r;

      t->n_canceled++;
      return 0;
290}

292static int transfer_on_pid(sd_event_source *s, const siginfo_t *si, void *userdata) {
      Transfer *t = userdata;
      bool_Bool success = false0;

      assert(s)do { if ((__builtin_expect(!!(!(s)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("s"), "../src/import/importd.c", 296, __PRETTY_FUNCTION__
); } while (0);
      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/import/importd.c", 297, __PRETTY_FUNCTION__
); } while (0);

      if (si->si_code == CLD_EXITEDCLD_EXITED) {
              if (si->si_status_sifields._sigchld.si_status != 0)
                      log_error("Import process failed with exit code %i.", si->si_status)({ 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/import/importd.c", 301, __func__, "Import process failed with exit code %i."
, si->_sifields._sigchld.si_status) : -abs(_e); });
              else {
                      log_debug("Import process succeeded.")({ 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/import/importd.c", 303, __func__, "Import process succeeded."
) : -abs(_e); });
                      success = true1;
              }

      } else if (IN_SET(si->si_code, CLD_KILLED, CLD_DUMPED)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){CLD_KILLED, CLD_DUMPED})/sizeof(int)]; switch
(si->si_code) { case CLD_KILLED: case CLD_DUMPED: _found =
 1; break; default: break; } _found; }))

              log_error("Import process terminated by signal %s.", signal_to_string(si->si_status))({ 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/import/importd.c", 309, __func__, "Import process terminated by signal %s."
, signal_to_string(si->_sifields._sigchld.si_status)) : -abs
(_e); });
      else
              log_error("Import process failed due to unknown reason.")({ 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/import/importd.c", 311, __func__, "Import process failed due to unknown reason."
) : -abs(_e); });

      t->pid = 0;

      return transfer_finalize(t, success);
316}

318static int transfer_on_log(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
      Transfer *t = userdata;
      ssize_t l;

      assert(s)do { if ((__builtin_expect(!!(!(s)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("s"), "../src/import/importd.c", 322, __PRETTY_FUNCTION__
); } while (0);
      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/import/importd.c", 323, __PRETTY_FUNCTION__
); } while (0);

      l = read(fd, t->log_message + t->log_message_size, sizeof(t->log_message) - t->log_message_size);
      if (l <= 0) {
              /* EOF/read error. We just close the pipe here, and
               * close the watch, waiting for the SIGCHLD to arrive,
               * before we do anything else. */

              if (l < 0)
                      log_error_errno(errno, "Failed to read log message: %m")({ int _level = ((3)), _e = (((*__errno_location ()))), _realm
 = (LOG_REALM_SYSTEMD); (log_get_max_level_realm(_realm) >=
 ((_level) & 0x07)) ? log_internal_realm(((_realm) <<
| (_level)), _e, "../src/import/importd.c", 332, __func__
, "Failed to read log message: %m") : -abs(_e); });

              t->log_event_source = sd_event_source_unref(t->log_event_source);
              return 0;
      }

      t->log_message_size += l;

      transfer_send_logs(t, false0);

      return 0;
343}

345static int transfer_start(Transfer *t) {
      _cleanup_close_pair___attribute__((cleanup(close_pairp))) int pipefd[2] = { -1, -1 };
      int r;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/import/importd.c", 349, __PRETTY_FUNCTION__
); } while (0);
      assert(t->pid <= 0)do { if ((__builtin_expect(!!(!(t->pid <= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t->pid <= 0"), "../src/import/importd.c"
, 350, __PRETTY_FUNCTION__); } while (0);

      if (pipe2(pipefd, O_CLOEXEC02000000) < 0)
              return -errno(*__errno_location ());

      r = safe_fork("(sd-transfer)", FORK_RESET_SIGNALS|FORK_DEATHSIG, &t->pid);
      if (r < 0)
              return r;
      if (r == 0) {
              const char *cmd[] = {
                      NULL((void*)0), /* systemd-import, systemd-export or systemd-pull */
                      NULL((void*)0), /* tar, raw  */
                      NULL((void*)0), /* --verify= */
                      NULL((void*)0), /* verify argument */
                      NULL((void*)0), /* maybe --force */
                      NULL((void*)0), /* maybe --read-only */
                      NULL((void*)0), /* if so: the actual URL */
                      NULL((void*)0), /* maybe --format= */
                      NULL((void*)0), /* if so: the actual format */
                      NULL((void*)0), /* remote */
                      NULL((void*)0), /* local */
                      NULL((void*)0)
              };
              unsigned k = 0;

              /* Child */

              pipefd[0] = safe_close(pipefd[0]);

              r = rearrange_stdio(t->stdin_fd,
                                  t->stdout_fd < 0 ? pipefd[1] : t->stdout_fd,
                                  pipefd[1]);
              if (r < 0) {
                      log_error_errno(r, "Failed to set stdin/stdout/stderr: %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/import/importd.c", 383, __func__, "Failed to set stdin/stdout/stderr: %m"
) : -abs(_e); });
                      _exit(EXIT_FAILURE1);
              }

              if (setenv("SYSTEMD_LOG_TARGET", "console-prefixed", 1) < 0 ||
                  setenv("NOTIFY_SOCKET", "/run/systemd/import/notify", 1) < 0) {
                      log_error_errno(errno, "setenv() failed: %m")({ int _level = ((3)), _e = (((*__errno_location ()))), _realm
 = (LOG_REALM_SYSTEMD); (log_get_max_level_realm(_realm) >=
 ((_level) & 0x07)) ? log_internal_realm(((_realm) <<
| (_level)), _e, "../src/import/importd.c", 389, __func__
, "setenv() failed: %m") : -abs(_e); });
                      _exit(EXIT_FAILURE1);
              }

              if (IN_SET(t->type, TRANSFER_IMPORT_TAR, TRANSFER_IMPORT_RAW)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){TRANSFER_IMPORT_TAR, TRANSFER_IMPORT_RAW
})/sizeof(int)]; switch(t->type) { case TRANSFER_IMPORT_TAR
: case TRANSFER_IMPORT_RAW: _found = 1; break; default: break
; } _found; }))
                      cmd[k++] = SYSTEMD_IMPORT_PATH"/usr/lib/systemd/systemd-import";
              else if (IN_SET(t->type, TRANSFER_EXPORT_TAR, TRANSFER_EXPORT_RAW)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){TRANSFER_EXPORT_TAR, TRANSFER_EXPORT_RAW
})/sizeof(int)]; switch(t->type) { case TRANSFER_EXPORT_TAR
: case TRANSFER_EXPORT_RAW: _found = 1; break; default: break
; } _found; }))
                      cmd[k++] = SYSTEMD_EXPORT_PATH"/usr/lib/systemd/systemd-export";
              else
                      cmd[k++] = SYSTEMD_PULL_PATH"/usr/lib/systemd/systemd-pull";

              if (IN_SET(t->type, TRANSFER_IMPORT_TAR, TRANSFER_EXPORT_TAR, TRANSFER_PULL_TAR)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){TRANSFER_IMPORT_TAR, TRANSFER_EXPORT_TAR
, TRANSFER_PULL_TAR})/sizeof(int)]; switch(t->type) { case
 TRANSFER_IMPORT_TAR: case TRANSFER_EXPORT_TAR: case TRANSFER_PULL_TAR
: _found = 1; break; default: break; } _found; }))
                      cmd[k++] = "tar";
              else
                      cmd[k++] = "raw";

              if (t->verify != _IMPORT_VERIFY_INVALID) {
                      cmd[k++] = "--verify";
                      cmd[k++] = import_verify_to_string(t->verify);
              }

              if (t->force_local)
                      cmd[k++] = "--force";
              if (t->read_only)
                      cmd[k++] = "--read-only";

              if (t->format) {
                      cmd[k++] = "--format";
                      cmd[k++] = t->format;
              }

              if (!IN_SET(t->type, TRANSFER_EXPORT_TAR, TRANSFER_EXPORT_RAW)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){TRANSFER_EXPORT_TAR, TRANSFER_EXPORT_RAW
})/sizeof(int)]; switch(t->type) { case TRANSFER_EXPORT_TAR
: case TRANSFER_EXPORT_RAW: _found = 1; break; default: break
; } _found; })) {
                      if (t->remote)
                              cmd[k++] = t->remote;
                      else
                              cmd[k++] = "-";
              }

              if (t->local)
                      cmd[k++] = t->local;
              cmd[k] = NULL((void*)0);

              execv(cmd[0], (char * const *) cmd);
              log_error_errno(errno, "Failed to execute %s tool: %m", cmd[0])({ int _level = ((3)), _e = (((*__errno_location ()))), _realm
 = (LOG_REALM_SYSTEMD); (log_get_max_level_realm(_realm) >=
 ((_level) & 0x07)) ? log_internal_realm(((_realm) <<
| (_level)), _e, "../src/import/importd.c", 432, __func__
, "Failed to execute %s tool: %m", cmd[0]) : -abs(_e); });
              _exit(EXIT_FAILURE1);
      }

      pipefd[1] = safe_close(pipefd[1]);
      t->log_fd = TAKE_FD(pipefd[0])({ int _fd_ = (pipefd[0]); (pipefd[0]) = -1; _fd_; });

      t->stdin_fd = safe_close(t->stdin_fd);

      r = sd_event_add_child(t->manager->event, &t->pid_event_source, t->pid, WEXITED4, transfer_on_pid, t);
      if (r < 0)
              return r;

      r = sd_event_add_io(t->manager->event, &t->log_event_source, t->log_fd, EPOLLINEPOLLIN, transfer_on_log, t);
      if (r < 0)
              return r;

      /* Make sure always process logging before SIGCHLD */
      r = sd_event_source_set_priority(t->log_event_source, SD_EVENT_PRIORITY_NORMAL -5);
      if (r < 0)
              return r;

      r = sd_bus_emit_signal(
                      t->manager->bus,
                      "/org/freedesktop/import1",
                      "org.freedesktop.import1.Manager",
                      "TransferNew",
                      "uo",
                      t->id,
                      t->object_path);
      if (r < 0)
              return r;

      return 0;
466}

468static Manager *manager_unref(Manager *m) {
      Transfer *t;

      if (!m)
              return NULL((void*)0);

      sd_event_source_unref(m->notify_event_source);
      safe_close(m->notify_fd);

      while ((t = hashmap_first(m->transfers)))
              transfer_unref(t);

      hashmap_free(m->transfers);

      bus_verify_polkit_async_registry_free(m->polkit_registry);

      m->bus = sd_bus_flush_close_unref(m->bus);
      sd_event_unref(m->event);

      return mfree(m);
488}

490DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_unref)static inline void manager_unrefp(Manager* *p) { if (*p) manager_unref
(*p); };

492static int manager_on_notify(sd_event_source *s, int fd, uint32_t revents, void *userdata) {

      char buf[NOTIFY_BUFFER_MAX4096+1];
      struct iovec iovec = {
              .iov_base = buf,
              .iov_len = sizeof(buf)-1,
      };
      union {
              struct cmsghdr cmsghdr;
              uint8_t buf[CMSG_SPACE(sizeof(struct ucred))((((sizeof(struct ucred)) + sizeof (size_t) - 1) & (size_t
) ~(sizeof (size_t) - 1)) + (((sizeof (struct cmsghdr)) + sizeof
 (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1))) +
                          CMSG_SPACE(sizeof(int) * NOTIFY_FD_MAX)((((sizeof(int) * 768) + sizeof (size_t) - 1) & (size_t) ~
(sizeof (size_t) - 1)) + (((sizeof (struct cmsghdr)) + sizeof
 (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1)))];
      } control = {};
      struct msghdr msghdr = {
              .msg_iov = &iovec,
              .msg_iovlen = 1,
              .msg_control = &control,
              .msg_controllen = sizeof(control),
      };
      struct ucred *ucred = NULL((void*)0);
      Manager *m = userdata;
      struct cmsghdr *cmsg;
      unsigned percent;
      char *p, *e;
      Transfer *t;
      Iterator i;
      ssize_t n;
      int r;

      n = recvmsg(fd, &msghdr, MSG_DONTWAITMSG_DONTWAIT|MSG_CMSG_CLOEXECMSG_CMSG_CLOEXEC);
      if (n < 0) {
              if (IN_SET(errno, EAGAIN, EINTR)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){11, 4})/sizeof(int)]; switch((*__errno_location
 ())) { case 11: case 4: _found = 1; break; default: break; }
 _found; }))
                      return 0;

              return -errno(*__errno_location ());
      }

      cmsg_close_all(&msghdr);

      CMSG_FOREACH(cmsg, &msghdr)for ((cmsg) = ((size_t) (&msghdr)->msg_controllen >=
 sizeof (struct cmsghdr) ? (struct cmsghdr *) (&msghdr)->
msg_control : (struct cmsghdr *) 0); (cmsg); (cmsg) = __cmsg_nxthdr
 ((&msghdr), (cmsg)))
              if (cmsg->cmsg_level == SOL_SOCKET1 &&
                  cmsg->cmsg_type == SCM_CREDENTIALSSCM_CREDENTIALS &&
                  cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))((((sizeof (struct cmsghdr)) + sizeof (size_t) - 1) & (size_t
) ~(sizeof (size_t) - 1)) + (sizeof(struct ucred))))
                      ucred = (struct ucred*) CMSG_DATA(cmsg)((cmsg)->__cmsg_data);

      if (msghdr.msg_flags & MSG_TRUNCMSG_TRUNC) {
              log_warning("Got overly long notification datagram, ignoring.")({ 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/import/importd.c", 537, __func__, "Got overly long notification datagram, ignoring."
) : -abs(_e); });
              return 0;
      }

      if (!ucred || ucred->pid <= 0) {
              log_warning("Got notification datagram lacking credential information, ignoring.")({ 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/import/importd.c", 542, __func__, "Got notification datagram lacking credential information, ignoring."
) : -abs(_e); });
              return 0;
      }

      HASHMAP_FOREACH(t, m->transfers, i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((m->transfers), &
(i), (void**)&(t), ((void*)0)); )
              if (ucred->pid == t->pid)
                      break;

      if (!t) {
              log_warning("Got notification datagram from unexpected peer, ignoring.")({ 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/import/importd.c", 551, __func__, "Got notification datagram from unexpected peer, ignoring."
) : -abs(_e); });
              return 0;
      }

      buf[n] = 0;

      p = startswith(buf, "X_IMPORT_PROGRESS=");
      if (!p) {
              p = strstr(buf, "\nX_IMPORT_PROGRESS=");
              if (!p)
                      return 0;

              p += 19;
      }

      e = strchrnul(p, '\n');
      *e = 0;

      r = safe_atou(p, &percent);
      if (r < 0 || percent > 100) {
              log_warning("Got invalid percent value, ignoring.")({ 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/import/importd.c", 571, __func__, "Got invalid percent value, ignoring."
) : -abs(_e); });
              return 0;
      }

      t->progress_percent = percent;

      log_debug("Got percentage from client: %u%%", percent)({ 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/import/importd.c", 577, __func__, "Got percentage from client: %u%%"
, percent) : -abs(_e); });
      return 0;
579}

581static int manager_new(Manager **ret) {
      _cleanup_(manager_unrefp)__attribute__((cleanup(manager_unrefp))) Manager *m = NULL((void*)0);
      static const union sockaddr_union sa = {
              .un.sun_family = AF_UNIX1,
              .un.sun_path = "/run/systemd/import/notify",
      };
      static const int one = 1;
      int r;

      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/import/importd.c", 590, __PRETTY_FUNCTION__
); } while (0);

      m = new0(Manager, 1)((Manager*) calloc((1), sizeof(Manager)));
      if (!m)
              return -ENOMEM12;

      r = sd_event_default(&m->event);
      if (r < 0)
              return r;

      sd_event_set_watchdog(m->event, true1);

      r = sd_bus_default_system(&m->bus);
      if (r < 0)
              return r;

      m->notify_fd = socket(AF_UNIX1, SOCK_DGRAMSOCK_DGRAM|SOCK_CLOEXECSOCK_CLOEXEC|SOCK_NONBLOCKSOCK_NONBLOCK, 0);
      if (m->notify_fd < 0)
              return -errno(*__errno_location ());

      (void) mkdir_parents_label(sa.un.sun_path, 0755);
      (void) unlink(sa.un.sun_path);

      if (bind(m->notify_fd, &sa.sa, SOCKADDR_UN_LEN(sa.un)({ const struct sockaddr_un *_sa = &(sa.un); do { if ((__builtin_expect
(!!(!(_sa->sun_family == 1)),0))) log_assert_failed_realm(
LOG_REALM_SYSTEMD, ("_sa->sun_family == AF_UNIX"), "../src/import/importd.c"
, 613, __PRETTY_FUNCTION__); } while (0); __builtin_offsetof(
struct sockaddr_un, sun_path) + (_sa->sun_path[0] == 0 ? 1
 + strnlen(_sa->sun_path+1, sizeof(_sa->sun_path)-1) : strnlen
(_sa->sun_path, sizeof(_sa->sun_path))); })) < 0)
              return -errno(*__errno_location ());

      if (setsockopt(m->notify_fd, SOL_SOCKET1, SO_PASSCRED16, &one, sizeof(one)) < 0)
              return -errno(*__errno_location ());

      r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLINEPOLLIN, manager_on_notify, m);
      if (r < 0)
              return r;

      *ret = TAKE_PTR(m)({ typeof(m) _ptr_ = (m); (m) = ((void*)0); _ptr_; });

      return 0;
626}

628static Transfer *manager_find(Manager *m, TransferType type, const char *remote) {
      Transfer *t;
      Iterator i;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/import/importd.c", 632, __PRETTY_FUNCTION__
); } while (0);
      assert(type >= 0)do { if ((__builtin_expect(!!(!(type >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("type >= 0"), "../src/import/importd.c"
, 633, __PRETTY_FUNCTION__); } while (0);
      assert(type < _TRANSFER_TYPE_MAX)do { if ((__builtin_expect(!!(!(type < _TRANSFER_TYPE_MAX)
),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("type < _TRANSFER_TYPE_MAX"
), "../src/import/importd.c", 634, __PRETTY_FUNCTION__); } while
 (0);

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

              if (t->type == type &&
                  streq_ptr(t->remote, remote))
                      return t;
      }

      return NULL((void*)0);
644}

646static int method_import_tar_or_raw(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
      _cleanup_(transfer_unrefp)__attribute__((cleanup(transfer_unrefp))) Transfer *t = NULL((void*)0);
      int fd, force, read_only, r;
      const char *local, *object;
      Manager *m = userdata;
      TransferType type;
      uint32_t id;

      assert(msg)do { if ((__builtin_expect(!!(!(msg)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("msg"), "../src/import/importd.c", 654, __PRETTY_FUNCTION__
); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/import/importd.c", 655, __PRETTY_FUNCTION__
); } while (0);

      r = bus_verify_polkit_async(
                      msg,
                      CAP_SYS_ADMIN21,
                      "org.freedesktop.import1.import",
                      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 = sd_bus_message_read(msg, "hsbb", &fd, &local, &force, &read_only);
      if (r < 0)
              return r;

      if (!machine_name_is_valid(local)hostname_is_valid(local, 0))
              return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Local name %s is invalid", local);

      r = setup_machine_directory((uint64_t) -1, error);
      if (r < 0)
              return r;

      type = streq_ptr(sd_bus_message_get_member(msg), "ImportTar") ? TRANSFER_IMPORT_TAR : TRANSFER_IMPORT_RAW;

      r = transfer_new(m, &t);
      if (r < 0)
              return r;

      t->type = type;
      t->force_local = force;
      t->read_only = read_only;

      t->local = strdup(local);
      if (!t->local)
              return -ENOMEM12;

      t->stdin_fd = fcntl(fd, F_DUPFD_CLOEXEC1030, 3);
      if (t->stdin_fd < 0)
              return -errno(*__errno_location ());

      r = transfer_start(t);
      if (r < 0)
              return r;

      object = t->object_path;
      id = t->id;
      t = NULL((void*)0);

      return sd_bus_reply_method_return(msg, "uo", id, object);
709}

711static int method_export_tar_or_raw(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
      _cleanup_(transfer_unrefp)__attribute__((cleanup(transfer_unrefp))) Transfer *t = NULL((void*)0);
      int fd, r;
      const char *local, *object, *format;
      Manager *m = userdata;
      TransferType type;
      uint32_t id;

      assert(msg)do { if ((__builtin_expect(!!(!(msg)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("msg"), "../src/import/importd.c", 719, __PRETTY_FUNCTION__
); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/import/importd.c", 720, __PRETTY_FUNCTION__
); } while (0);

      r = bus_verify_polkit_async(
                      msg,
                      CAP_SYS_ADMIN21,
                      "org.freedesktop.import1.export",
                      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 = sd_bus_message_read(msg, "shs", &local, &fd, &format);
      if (r < 0)
              return r;

      if (!machine_name_is_valid(local)hostname_is_valid(local, 0))
              return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Local name %s is invalid", local);

      type = streq_ptr(sd_bus_message_get_member(msg), "ExportTar") ? TRANSFER_EXPORT_TAR : TRANSFER_EXPORT_RAW;

      r = transfer_new(m, &t);
      if (r < 0)
              return r;

      t->type = type;

      if (!isempty(format)) {
              t->format = strdup(format);
              if (!t->format)
                      return -ENOMEM12;
      }

      t->local = strdup(local);
      if (!t->local)
              return -ENOMEM12;

      t->stdout_fd = fcntl(fd, F_DUPFD_CLOEXEC1030, 3);
      if (t->stdout_fd < 0)
              return -errno(*__errno_location ());

      r = transfer_start(t);
      if (r < 0)
              return r;

      object = t->object_path;
      id = t->id;
      t = NULL((void*)0);

      return sd_bus_reply_method_return(msg, "uo", id, object);
774}

776static int method_pull_tar_or_raw(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
      _cleanup_(transfer_unrefp)__attribute__((cleanup(transfer_unrefp))) Transfer *t = NULL((void*)0);
      const char *remote, *local, *verify, *object;
      Manager *m = userdata;
      ImportVerify v;
      TransferType type;
      int force, r;
      uint32_t id;

      assert(msg)do { if ((__builtin_expect(!!(!(msg)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("msg"), "../src/import/importd.c", 785, __PRETTY_FUNCTION__
); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/import/importd.c", 786, __PRETTY_FUNCTION__
); } while (0);

      r = bus_verify_polkit_async(
                      msg,
                      CAP_SYS_ADMIN21,
                      "org.freedesktop.import1.pull",
                      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 = sd_bus_message_read(msg, "sssb", &remote, &local, &verify, &force);
      if (r < 0)
              return r;

      if (!http_url_is_valid(remote))
              return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "URL %s is invalid", remote);

      if (isempty(local))
              local = NULL((void*)0);
      else if (!machine_name_is_valid(local)hostname_is_valid(local, 0))
              return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Local name %s is invalid", local);

      if (isempty(verify))
              v = IMPORT_VERIFY_SIGNATURE;
      else
              v = import_verify_from_string(verify);
      if (v < 0)
              return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Unknown verification mode %s", verify);

      r = setup_machine_directory((uint64_t) -1, error);
      if (r < 0)
              return r;

      type = streq_ptr(sd_bus_message_get_member(msg), "PullTar") ? TRANSFER_PULL_TAR : TRANSFER_PULL_RAW;

      if (manager_find(m, type, remote))
              return sd_bus_error_setf(error, BUS_ERROR_TRANSFER_IN_PROGRESS"org.freedesktop.import1.TransferInProgress", "Transfer for %s already in progress.", remote);

      r = transfer_new(m, &t);
      if (r < 0)
              return r;

      t->type = type;
      t->verify = v;
      t->force_local = force;

      t->remote = strdup(remote);
      if (!t->remote)
              return -ENOMEM12;

      if (local) {
              t->local = strdup(local);
              if (!t->local)
                      return -ENOMEM12;
      }

      r = transfer_start(t);
      if (r < 0)
              return r;

      object = t->object_path;
      id = t->id;
      t = NULL((void*)0);

      return sd_bus_reply_method_return(msg, "uo", id, object);
857}

859static int method_list_transfers(sd_bus_message *msg, 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;
      Transfer *t;
      Iterator i;
      int r;

      assert(msg)do { if ((__builtin_expect(!!(!(msg)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("msg"), "../src/import/importd.c", 866, __PRETTY_FUNCTION__
); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/import/importd.c", 867, __PRETTY_FUNCTION__
); } while (0);

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

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

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

              r = sd_bus_message_append(
                              reply,
                              "(usssdo)",
                              t->id,
                              transfer_type_to_string(t->type),
                              t->remote,
                              t->local,
                              (double) t->progress_percent / 100.0,
                              t->object_path);
              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));
897}

899static int method_cancel(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
      Transfer *t = userdata;
      int r;

      assert(msg)do { if ((__builtin_expect(!!(!(msg)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("msg"), "../src/import/importd.c", 903, __PRETTY_FUNCTION__
); } while (0);
      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/import/importd.c", 904, __PRETTY_FUNCTION__
); } while (0);

      r = bus_verify_polkit_async(
                      msg,
                      CAP_SYS_ADMIN21,
                      "org.freedesktop.import1.pull",
                      NULL((void*)0),
                      false0,
                      UID_INVALID((uid_t) -1),
                      &t->manager->polkit_registry,
                      error);
      if (r < 0)
              return r;
      if (r == 0)
              return 1; /* Will call us back */

      r = transfer_cancel(t);
      if (r < 0)
              return r;

      return sd_bus_reply_method_return(msg, NULL((void*)0));
925}

927static int method_cancel_transfer(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
      Manager *m = userdata;
      Transfer *t;
      uint32_t id;
      int r;

      assert(msg)do { if ((__builtin_expect(!!(!(msg)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("msg"), "../src/import/importd.c", 933, __PRETTY_FUNCTION__
); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/import/importd.c", 934, __PRETTY_FUNCTION__
); } while (0);

      r = bus_verify_polkit_async(
                      msg,
                      CAP_SYS_ADMIN21,
                      "org.freedesktop.import1.pull",
                      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 = sd_bus_message_read(msg, "u", &id);
      if (r < 0)
              return r;
      if (id <= 0)
              return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Invalid transfer id");

      t = hashmap_get(m->transfers, UINT32_TO_PTR(id)((void *) ((uintptr_t) (id))));
      if (!t)
              return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_TRANSFER"org.freedesktop.import1.NoSuchTransfer", "No transfer by id %" PRIu32"u", id);

      r = transfer_cancel(t);
      if (r < 0)
              return r;

      return sd_bus_reply_method_return(msg, NULL((void*)0));
965}

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

      Transfer *t = userdata;

      assert(bus)do { if ((__builtin_expect(!!(!(bus)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/import/importd.c", 978, __PRETTY_FUNCTION__
); } while (0);
      assert(reply)do { if ((__builtin_expect(!!(!(reply)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("reply"), "../src/import/importd.c", 979
, __PRETTY_FUNCTION__); } while (0);
      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/import/importd.c", 980, __PRETTY_FUNCTION__
); } while (0);

      return sd_bus_message_append(reply, "d", (double) t->progress_percent / 100.0);
983}

985static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_type, transfer_type, TransferType)int property_get_type(sd_bus *bus, const char *path, const char
 *interface, const char *property, sd_bus_message *reply, void
 *userdata, sd_bus_error *error) { TransferType *data = userdata
; do { if ((__builtin_expect(!!(!(bus)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/import/importd.c", 985, __PRETTY_FUNCTION__
); } while (0); do { if ((__builtin_expect(!!(!(reply)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("reply"), "../src/import/importd.c", 985
, __PRETTY_FUNCTION__); } while (0); do { if ((__builtin_expect
(!!(!(data)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, (
"data"), "../src/import/importd.c", 985, __PRETTY_FUNCTION__)
; } while (0); return sd_bus_message_append(reply, "s", transfer_type_to_string
((*(data)))); };
986static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_verify, import_verify, ImportVerify)int property_get_verify(sd_bus *bus, const char *path, const char
 *interface, const char *property, sd_bus_message *reply, void
 *userdata, sd_bus_error *error) { ImportVerify *data = userdata
; do { if ((__builtin_expect(!!(!(bus)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/import/importd.c", 986, __PRETTY_FUNCTION__
); } while (0); do { if ((__builtin_expect(!!(!(reply)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("reply"), "../src/import/importd.c", 986
, __PRETTY_FUNCTION__); } while (0); do { if ((__builtin_expect
(!!(!(data)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, (
"data"), "../src/import/importd.c", 986, __PRETTY_FUNCTION__)
; } while (0); return sd_bus_message_append(reply, "s", import_verify_to_string
((*(data)))); };

988static const sd_bus_vtable transfer_vtable[] = {
      SD_BUS_VTABLE_START(0){ .type = _SD_BUS_VTABLE_START, .flags = 0, .x = { .start = {
 .element_size = sizeof(sd_bus_vtable) }, }, },
      SD_BUS_PROPERTY("Id", "u", NULL, offsetof(Transfer, id), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "Id", .signature = "u", .get
 = ((void*)0), .set = ((void*)0), .offset = __builtin_offsetof
(Transfer, id), }, }, },
      SD_BUS_PROPERTY("Local", "s", NULL, offsetof(Transfer, local), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "Local", .signature = "s", .
get = ((void*)0), .set = ((void*)0), .offset = __builtin_offsetof
(Transfer, local), }, }, },
      SD_BUS_PROPERTY("Remote", "s", NULL, offsetof(Transfer, remote), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "Remote", .signature = "s", .
get = ((void*)0), .set = ((void*)0), .offset = __builtin_offsetof
(Transfer, remote), }, }, },
      SD_BUS_PROPERTY("Type", "s", property_get_type, offsetof(Transfer, type), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "Type", .signature = "s", .get
 = property_get_type, .set = ((void*)0), .offset = __builtin_offsetof
(Transfer, type), }, }, },
      SD_BUS_PROPERTY("Verify", "s", property_get_verify, offsetof(Transfer, verify), SD_BUS_VTABLE_PROPERTY_CONST){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = SD_BUS_VTABLE_PROPERTY_CONST
, .x = { .property = { .member = "Verify", .signature = "s", .
get = property_get_verify, .set = ((void*)0), .offset = __builtin_offsetof
(Transfer, verify), }, }, },
      SD_BUS_PROPERTY("Progress", "d", property_get_progress, 0, 0){ .type = _SD_BUS_VTABLE_PROPERTY, .flags = 0, .x = { .property
 = { .member = "Progress", .signature = "d", .get = property_get_progress
, .set = ((void*)0), .offset = 0, }, }, },
      SD_BUS_METHOD("Cancel", NULL, NULL, method_cancel, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "Cancel", .signature = ((void*
)0), .result = ((void*)0), .handler = method_cancel, .offset =
 0, }, }, },
      SD_BUS_SIGNAL("LogMessage", "us", 0){ .type = _SD_BUS_VTABLE_SIGNAL, .flags = 0, .x = { .signal =
 { .member = "LogMessage", .signature = "us", }, }, },
      SD_BUS_VTABLE_END{ .type = _SD_BUS_VTABLE_END, .flags = 0, .x = { { 0 } }, },
999};

1001static const 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_METHOD("ImportTar", "hsbb", "uo", method_import_tar_or_raw, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "ImportTar", .signature = "hsbb"
, .result = "uo", .handler = method_import_tar_or_raw, .offset
 = 0, }, }, },
      SD_BUS_METHOD("ImportRaw", "hsbb", "uo", method_import_tar_or_raw, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "ImportRaw", .signature = "hsbb"
, .result = "uo", .handler = method_import_tar_or_raw, .offset
 = 0, }, }, },
      SD_BUS_METHOD("ExportTar", "shs", "uo", method_export_tar_or_raw, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "ExportTar", .signature = "shs"
, .result = "uo", .handler = method_export_tar_or_raw, .offset
 = 0, }, }, },
      SD_BUS_METHOD("ExportRaw", "shs", "uo", method_export_tar_or_raw, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "ExportRaw", .signature = "shs"
, .result = "uo", .handler = method_export_tar_or_raw, .offset
 = 0, }, }, },
      SD_BUS_METHOD("PullTar", "sssb", "uo", method_pull_tar_or_raw, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "PullTar", .signature = "sssb"
, .result = "uo", .handler = method_pull_tar_or_raw, .offset =
 0, }, }, },
      SD_BUS_METHOD("PullRaw", "sssb", "uo", method_pull_tar_or_raw, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "PullRaw", .signature = "sssb"
, .result = "uo", .handler = method_pull_tar_or_raw, .offset =
 0, }, }, },
      SD_BUS_METHOD("ListTransfers", NULL, "a(usssdo)", method_list_transfers, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "ListTransfers", .signature = (
(void*)0), .result = "a(usssdo)", .handler = method_list_transfers
, .offset = 0, }, }, },
      SD_BUS_METHOD("CancelTransfer", "u", NULL, method_cancel_transfer, SD_BUS_VTABLE_UNPRIVILEGED){ .type = _SD_BUS_VTABLE_METHOD, .flags = SD_BUS_VTABLE_UNPRIVILEGED
, .x = { .method = { .member = "CancelTransfer", .signature =
 "u", .result = ((void*)0), .handler = method_cancel_transfer
, .offset = 0, }, }, },
      SD_BUS_SIGNAL("TransferNew", "uo", 0){ .type = _SD_BUS_VTABLE_SIGNAL, .flags = 0, .x = { .signal =
 { .member = "TransferNew", .signature = "uo", }, }, },
      SD_BUS_SIGNAL("TransferRemoved", "uos", 0){ .type = _SD_BUS_VTABLE_SIGNAL, .flags = 0, .x = { .signal =
 { .member = "TransferRemoved", .signature = "uos", }, }, },
      SD_BUS_VTABLE_END{ .type = _SD_BUS_VTABLE_END, .flags = 0, .x = { { 0 } }, },
1014};

1016static int transfer_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
      Manager *m = userdata;
      Transfer *t;
      const char *p;
      uint32_t id;
      int r;

      assert(bus)do { if ((__builtin_expect(!!(!(bus)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/import/importd.c", 1023,
 __PRETTY_FUNCTION__); } while (0);
      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/import/importd.c", 1024
, __PRETTY_FUNCTION__); } while (0);
      assert(interface)do { if ((__builtin_expect(!!(!(interface)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("interface"), "../src/import/importd.c",
 1025, __PRETTY_FUNCTION__); } while (0);
      assert(found)do { if ((__builtin_expect(!!(!(found)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("found"), "../src/import/importd.c", 1026
, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/import/importd.c", 1027, __PRETTY_FUNCTION__
); } while (0);

      p = startswith(path, "/org/freedesktop/import1/transfer/_");
      if (!p)
              return 0;

      r = safe_atou32(p, &id);
      if (r < 0 || id == 0)
              return 0;

      t = hashmap_get(m->transfers, UINT32_TO_PTR(id)((void *) ((uintptr_t) (id))));
      if (!t)
              return 0;

      *found = t;
      return 1;
1043}

1045static int transfer_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
      _cleanup_strv_free___attribute__((cleanup(strv_freep))) char **l = NULL((void*)0);
      Manager *m = userdata;
      Transfer *t;
      unsigned k = 0;
      Iterator i;

      l = new0(char*, hashmap_size(m->transfers) + 1)((char**) calloc((hashmap_size(m->transfers) + 1), sizeof(
char*)));
1
Memory is allocated→
      if (!l)
2
←
Assuming 'l' is non-null→
3
←
Taking false branch→
              return -ENOMEM12;

      HASHMAP_FOREACH(t, m->transfers, i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((m->transfers), &
(i), (void**)&(t), ((void*)0)); ) {
4
←
Loop condition is true.  Entering loop body→

              l[k] = strdup(t->object_path);
              if (!l[k])
5
←
Assuming the condition is true→
6
←
Taking true branch→
                      return -ENOMEM12;
7
←
Potential leak of memory pointed to by 'l'

              k++;
      }

      *nodes = TAKE_PTR(l)({ typeof(l) _ptr_ = (l); (l) = ((void*)0); _ptr_; });

      return 1;
1068}

1070static int manager_add_bus_objects(Manager *m) {
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/import/importd.c", 1073, __PRETTY_FUNCTION__
); } while (0);

      r = sd_bus_add_object_vtable(m->bus, NULL((void*)0), "/org/freedesktop/import1", "org.freedesktop.import1.Manager", manager_vtable, m);
      if (r < 0)
              return log_error_errno(r, "Failed to register object: %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/import/importd.c", 1077, __func__, "Failed to register object: %m"
) : -abs(_e); });

      r = sd_bus_add_fallback_vtable(m->bus, NULL((void*)0), "/org/freedesktop/import1/transfer", "org.freedesktop.import1.Transfer", transfer_vtable, transfer_object_find, m);
      if (r < 0)
              return log_error_errno(r, "Failed to register object: %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/import/importd.c", 1081, __func__, "Failed to register object: %m"
) : -abs(_e); });

      r = sd_bus_add_node_enumerator(m->bus, NULL((void*)0), "/org/freedesktop/import1/transfer", transfer_node_enumerator, m);
      if (r < 0)
              return log_error_errno(r, "Failed to add transfer enumerator: %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/import/importd.c", 1085, __func__, "Failed to add transfer enumerator: %m"
) : -abs(_e); });

      r = sd_bus_request_name_async(m->bus, NULL((void*)0), "org.freedesktop.import1", 0, NULL((void*)0), NULL((void*)0));
      if (r < 0)
              return log_error_errno(r, "Failed to request name: %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/import/importd.c", 1089, __func__, "Failed to request name: %m"
) : -abs(_e); });

      r = sd_bus_attach_event(m->bus, m->event, 0);
      if (r < 0)
              return log_error_errno(r, "Failed to attach bus to event loop: %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/import/importd.c", 1093, __func__, "Failed to attach bus to event loop: %m"
) : -abs(_e); });

      return 0;
1096}

1098static bool_Bool manager_check_idle(void *userdata) {
      Manager *m = userdata;

      return hashmap_isempty(m->transfers);
1102}

1104static int manager_run(Manager *m) {
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/import/importd.c", 1105, __PRETTY_FUNCTION__
); } while (0);

      return bus_event_loop_with_idle(
                      m->event,
                      m->bus,
                      "org.freedesktop.import1",
                      DEFAULT_EXIT_USEC(30*((usec_t) 1000000ULL)),
                      manager_check_idle,
                      m);
1114}

1116int main(int argc, char *argv[]) {
      _cleanup_(manager_unrefp)__attribute__((cleanup(manager_unrefp))) Manager *m = NULL((void*)0);
      int r;

      log_set_target(LOG_TARGET_AUTO);
      log_parse_environment()log_parse_environment_realm(LOG_REALM_SYSTEMD);
      log_open();

      umask(0022);

      if (argc != 1) {
              log_error("This program takes no arguments.")({ 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/import/importd.c", 1127, __func__, "This program takes no arguments."
) : -abs(_e); });
              r = -EINVAL22;
              goto finish;
      }

      assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGCHLD, -1) >= 0)do { if ((__builtin_expect(!!(!(sigprocmask_many(0, ((void*)0
), 17, -1) >= 0)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("sigprocmask_many(SIG_BLOCK, NULL, SIGCHLD, -1) >= 0"),
 "../src/import/importd.c", 1132, __PRETTY_FUNCTION__); } while
 (0);

      r = manager_new(&m);
      if (r < 0) {
              log_error_errno(r, "Failed to allocate manager object: %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/import/importd.c", 1136, __func__, "Failed to allocate manager object: %m"
) : -abs(_e); });
              goto finish;
      }

      r = manager_add_bus_objects(m);
      if (r < 0)
              goto finish;

      r = manager_run(m);
      if (r < 0) {
              log_error_errno(r, "Failed to run event loop: %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/import/importd.c", 1146, __func__, "Failed to run event loop: %m"
) : -abs(_e); });
              goto finish;
      }

1150finish:
      return r < 0 ? EXIT_FAILURE1 : EXIT_SUCCESS0;
1152}