src/import/importd.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <sys/prctl.h>
   4 #include <sys/wait.h>
   5
   6 #include "sd-bus.h"
   7
   8 #include "alloc-util.h"
   9 #include "bus-common-errors.h"
  10 #include "bus-polkit.h"
  11 #include "def.h"
  12 #include "fd-util.h"
  13 #include "float.h"
  14 #include "hostname-util.h"
  15 #include "import-util.h"
  16 #include "machine-pool.h"
  17 #include "main-func.h"
  18 #include "missing_capability.h"
  19 #include "mkdir.h"
  20 #include "parse-util.h"
  21 #include "path-util.h"
  22 #include "process-util.h"
  23 #include "signal-util.h"
  24 #include "socket-util.h"
  25 #include "stat-util.h"
  26 #include "string-table.h"
  27 #include "strv.h"
  28 #include "syslog-util.h"
  29 #include "user-util.h"
  30 #include "util.h"
  31 #include "web-util.h"
  32
  33 typedef struct Transfer Transfer;
  34 typedef struct Manager Manager;
  35
  36 typedef enum TransferType {
  37         TRANSFER_IMPORT_TAR,
  38         TRANSFER_IMPORT_RAW,
  39         TRANSFER_IMPORT_FS,
  40         TRANSFER_EXPORT_TAR,
  41         TRANSFER_EXPORT_RAW,
  42         TRANSFER_PULL_TAR,
  43         TRANSFER_PULL_RAW,
  44         _TRANSFER_TYPE_MAX,
  45         _TRANSFER_TYPE_INVALID = -1,
  46 } TransferType;
  47
  48 struct Transfer {
  49         Manager *manager;
  50
  51         uint32_t id;
  52         char *object_path;
  53
  54         TransferType type;
  55         ImportVerify verify;
  56
  57         char *remote;
  58         char *local;
  59         bool force_local;
  60         bool read_only;
  61
  62         char *format;
  63
  64         pid_t pid;
  65
  66         int log_fd;
  67
  68         char log_message[LINE_MAX];
  69         size_t log_message_size;
  70
  71         sd_event_source *pid_event_source;
  72         sd_event_source *log_event_source;
  73
  74         unsigned n_canceled;
  75         unsigned progress_percent;
  76
  77         int stdin_fd;
  78         int stdout_fd;
  79 };
  80
  81 struct Manager {
  82         sd_event *event;
  83         sd_bus *bus;
  84
  85         uint32_t current_transfer_id;
  86         Hashmap *transfers;
  87
  88         Hashmap *polkit_registry;
  89
  90         int notify_fd;
  91
  92         sd_event_source *notify_event_source;
  93 };
  94
  95 #define TRANSFERS_MAX 64
  96
  97 static const char* const transfer_type_table[_TRANSFER_TYPE_MAX] = {
  98         [TRANSFER_IMPORT_TAR] = "import-tar",
  99         [TRANSFER_IMPORT_RAW] = "import-raw",
 100         [TRANSFER_IMPORT_FS] = "import-fs",
 101         [TRANSFER_EXPORT_TAR] = "export-tar",
 102         [TRANSFER_EXPORT_RAW] = "export-raw",
 103         [TRANSFER_PULL_TAR] = "pull-tar",
 104         [TRANSFER_PULL_RAW] = "pull-raw",
 105 };
 106
 107 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(transfer_type, TransferType);
 108
 109 static Transfer *transfer_unref(Transfer *t) {
 110         if (!t)
 111                 return NULL;
 112
 113         if (t->manager)
 114                 hashmap_remove(t->manager->transfers, UINT32_TO_PTR(t->id));
 115
 116         sd_event_source_unref(t->pid_event_source);
 117         sd_event_source_unref(t->log_event_source);
 118
 119         free(t->remote);
 120         free(t->local);
 121         free(t->format);
 122         free(t->object_path);
 123
 124         if (t->pid > 0) {
 125                 (void) kill_and_sigcont(t->pid, SIGKILL);
 126                 (void) wait_for_terminate(t->pid, NULL);
 127         }
 128
 129         safe_close(t->log_fd);
 130         safe_close(t->stdin_fd);
 131         safe_close(t->stdout_fd);
 132
 133         return mfree(t);
 134 }
 135
 136 DEFINE_TRIVIAL_CLEANUP_FUNC(Transfer*, transfer_unref);
 137
 138 static int transfer_new(Manager *m, Transfer **ret) {
 139         _cleanup_(transfer_unrefp) Transfer *t = NULL;
 140         uint32_t id;
 141         int r;
 142
 143         assert(m);
 144         assert(ret);
 145
 146         if (hashmap_size(m->transfers) >= TRANSFERS_MAX)
 147                 return -E2BIG;
 148
 149         r = hashmap_ensure_allocated(&m->transfers, &trivial_hash_ops);
 150         if (r < 0)
 151                 return r;
 152
 153         t = new(Transfer, 1);
 154         if (!t)
 155                 return -ENOMEM;
 156
 157         *t = (Transfer) {
 158                 .type = _TRANSFER_TYPE_INVALID,
 159                 .log_fd = -1,
 160                 .stdin_fd = -1,
 161                 .stdout_fd = -1,
 162                 .verify = _IMPORT_VERIFY_INVALID,
 163                 .progress_percent= (unsigned) -1,
 164         };
 165
 166         id = m->current_transfer_id + 1;
 167
 168         if (asprintf(&t->object_path, "/org/freedesktop/import1/transfer/_%" PRIu32, id) < 0)
 169                 return -ENOMEM;
 170
 171         r = hashmap_put(m->transfers, UINT32_TO_PTR(id), t);
 172         if (r < 0)
 173                 return r;
 174
 175         m->current_transfer_id = id;
 176
 177         t->manager = m;
 178         t->id = id;
 179
 180         *ret = TAKE_PTR(t);
 181
 182         return 0;
 183 }
 184
 185 static double transfer_percent_as_double(Transfer *t) {
 186         assert(t);
 187
 188         if (t->progress_percent == (unsigned) -1)
 189                 return -DBL_MAX;
 190
 191         return (double) t->progress_percent / 100.0;
 192 }
 193
 194 static void transfer_send_log_line(Transfer *t, const char *line) {
 195         int r, priority = LOG_INFO;
 196
 197         assert(t);
 198         assert(line);
 199
 200         syslog_parse_priority(&line, &priority, true);
 201
 202         log_full(priority, "(transfer%" PRIu32 ") %s", t->id, line);
 203
 204         r = sd_bus_emit_signal(
 205                         t->manager->bus,
 206                         t->object_path,
 207                         "org.freedesktop.import1.Transfer",
 208                         "LogMessage",
 209                         "us",
 210                         priority,
 211                         line);
 212         if (r < 0)
 213                 log_warning_errno(r, "Cannot emit log message signal, ignoring: %m");
 214  }
 215
 216 static void transfer_send_logs(Transfer *t, bool flush) {
 217         assert(t);
 218
 219         /* Try to send out all log messages, if we can. But if we
 220          * can't we remove the messages from the buffer, but don't
 221          * fail */
 222
 223         while (t->log_message_size > 0) {
 224                 _cleanup_free_ char *n = NULL;
 225                 char *e;
 226
 227                 if (t->log_message_size >= sizeof(t->log_message))
 228                         e = t->log_message + sizeof(t->log_message);
 229                 else {
 230                         char *a, *b;
 231
 232                         a = memchr(t->log_message, 0, t->log_message_size);
 233                         b = memchr(t->log_message, '\n', t->log_message_size);
 234
 235                         if (a && b)
 236                                 e = a < b ? a : b;
 237                         else if (a)
 238                                 e = a;
 239                         else
 240                                 e = b;
 241                 }
 242
 243                 if (!e) {
 244                         if (!flush)
 245                                 return;
 246
 247                         e = t->log_message + t->log_message_size;
 248                 }
 249
 250                 n = strndup(t->log_message, e - t->log_message);
 251
 252                 /* Skip over NUL and newlines */
 253                 while (e < t->log_message + t->log_message_size && IN_SET(*e, 0, '\n'))
 254                         e++;
 255
 256                 memmove(t->log_message, e, t->log_message + sizeof(t->log_message) - e);
 257                 t->log_message_size -= e - t->log_message;
 258
 259                 if (!n) {
 260                         log_oom();
 261                         continue;
 262                 }
 263
 264                 if (isempty(n))
 265                         continue;
 266
 267                 transfer_send_log_line(t, n);
 268         }
 269 }
 270
 271 static int transfer_finalize(Transfer *t, bool success) {
 272         int r;
 273
 274         assert(t);
 275
 276         transfer_send_logs(t, true);
 277
 278         r = sd_bus_emit_signal(
 279                         t->manager->bus,
 280                         "/org/freedesktop/import1",
 281                         "org.freedesktop.import1.Manager",
 282                         "TransferRemoved",
 283                         "uos",
 284                         t->id,
 285                         t->object_path,
 286                         success ? "done" :
 287                         t->n_canceled > 0 ? "canceled" : "failed");
 288
 289         if (r < 0)
 290                 log_error_errno(r, "Cannot emit message: %m");
 291
 292         transfer_unref(t);
 293         return 0;
 294 }
 295
 296 static int transfer_cancel(Transfer *t) {
 297         int r;
 298
 299         assert(t);
 300
 301         r = kill_and_sigcont(t->pid, t->n_canceled < 3 ? SIGTERM : SIGKILL);
 302         if (r < 0)
 303                 return r;
 304
 305         t->n_canceled++;
 306         return 0;
 307 }
 308
 309 static int transfer_on_pid(sd_event_source *s, const siginfo_t *si, void *userdata) {
 310         Transfer *t = userdata;
 311         bool success = false;
 312
 313         assert(s);
 314         assert(t);
 315
 316         if (si->si_code == CLD_EXITED) {
 317                 if (si->si_status != 0)
 318                         log_error("Transfer process failed with exit code %i.", si->si_status);
 319                 else {
 320                         log_debug("Transfer process succeeded.");
 321                         success = true;
 322                 }
 323
 324         } else if (IN_SET(si->si_code, CLD_KILLED, CLD_DUMPED))
 325                 log_error("Transfer process terminated by signal %s.", signal_to_string(si->si_status));
 326         else
 327                 log_error("Transfer process failed due to unknown reason.");
 328
 329         t->pid = 0;
 330
 331         return transfer_finalize(t, success);
 332 }
 333
 334 static int transfer_on_log(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 335         Transfer *t = userdata;
 336         ssize_t l;
 337
 338         assert(s);
 339         assert(t);
 340
 341         l = read(fd, t->log_message + t->log_message_size, sizeof(t->log_message) - t->log_message_size);
 342         if (l < 0)
 343                 log_error_errno(errno, "Failed to read log message: %m");
 344         if (l <= 0) {
 345                 /* EOF/read error. We just close the pipe here, and
 346                  * close the watch, waiting for the SIGCHLD to arrive,
 347                  * before we do anything else. */
 348                 t->log_event_source = sd_event_source_unref(t->log_event_source);
 349                 return 0;
 350         }
 351
 352         t->log_message_size += l;
 353
 354         transfer_send_logs(t, false);
 355
 356         return 0;
 357 }
 358
 359 static int transfer_start(Transfer *t) {
 360         _cleanup_close_pair_ int pipefd[2] = { -1, -1 };
 361         int r;
 362
 363         assert(t);
 364         assert(t->pid <= 0);
 365
 366         if (pipe2(pipefd, O_CLOEXEC) < 0)
 367                 return -errno;
 368
 369         r = safe_fork("(sd-transfer)", FORK_RESET_SIGNALS|FORK_DEATHSIG, &t->pid);
 370         if (r < 0)
 371                 return r;
 372         if (r == 0) {
 373                 const char *cmd[] = {
 374                         NULL, /* systemd-import, systemd-import-fs, systemd-export or systemd-pull */
 375                         NULL, /* tar, raw  */
 376                         NULL, /* --verify= */
 377                         NULL, /* verify argument */
 378                         NULL, /* maybe --force */
 379                         NULL, /* maybe --read-only */
 380                         NULL, /* if so: the actual URL */
 381                         NULL, /* maybe --format= */
 382                         NULL, /* if so: the actual format */
 383                         NULL, /* remote */
 384                         NULL, /* local */
 385                         NULL
 386                 };
 387                 unsigned k = 0;
 388
 389                 /* Child */
 390
 391                 pipefd[0] = safe_close(pipefd[0]);
 392
 393                 r = rearrange_stdio(t->stdin_fd,
 394                                     t->stdout_fd < 0 ? pipefd[1] : t->stdout_fd,
 395                                     pipefd[1]);
 396                 if (r < 0) {
 397                         log_error_errno(r, "Failed to set stdin/stdout/stderr: %m");
 398                         _exit(EXIT_FAILURE);
 399                 }
 400
 401                 if (setenv("SYSTEMD_LOG_TARGET", "console-prefixed", 1) < 0 ||
 402                     setenv("NOTIFY_SOCKET", "/run/systemd/import/notify", 1) < 0) {
 403                         log_error_errno(errno, "setenv() failed: %m");
 404                         _exit(EXIT_FAILURE);
 405                 }
 406
 407                 switch (t->type) {
 408
 409                 case TRANSFER_IMPORT_TAR:
 410                 case TRANSFER_IMPORT_RAW:
 411                         cmd[k++] = SYSTEMD_IMPORT_PATH;
 412                         break;
 413
 414                 case TRANSFER_IMPORT_FS:
 415                         cmd[k++] = SYSTEMD_IMPORT_FS_PATH;
 416                         break;
 417
 418                 case TRANSFER_EXPORT_TAR:
 419                 case TRANSFER_EXPORT_RAW:
 420                         cmd[k++] = SYSTEMD_EXPORT_PATH;
 421                         break;
 422
 423                 case TRANSFER_PULL_TAR:
 424                 case TRANSFER_PULL_RAW:
 425                         cmd[k++] = SYSTEMD_PULL_PATH;
 426                         break;
 427
 428                 default:
 429                         assert_not_reached("Unexpected transfer type");
 430                 }
 431
 432                 switch (t->type) {
 433
 434                 case TRANSFER_IMPORT_TAR:
 435                 case TRANSFER_EXPORT_TAR:
 436                 case TRANSFER_PULL_TAR:
 437                         cmd[k++] = "tar";
 438                         break;
 439
 440                 case TRANSFER_IMPORT_RAW:
 441                 case TRANSFER_EXPORT_RAW:
 442                 case TRANSFER_PULL_RAW:
 443                         cmd[k++] = "raw";
 444                         break;
 445
 446                 case TRANSFER_IMPORT_FS:
 447                         cmd[k++] = "run";
 448                         break;
 449
 450                 default:
 451                         break;
 452                 }
 453
 454                 if (t->verify != _IMPORT_VERIFY_INVALID) {
 455                         cmd[k++] = "--verify";
 456                         cmd[k++] = import_verify_to_string(t->verify);
 457                 }
 458
 459                 if (t->force_local)
 460                         cmd[k++] = "--force";
 461                 if (t->read_only)
 462                         cmd[k++] = "--read-only";
 463
 464                 if (t->format) {
 465                         cmd[k++] = "--format";
 466                         cmd[k++] = t->format;
 467                 }
 468
 469                 if (!IN_SET(t->type, TRANSFER_EXPORT_TAR, TRANSFER_EXPORT_RAW)) {
 470                         if (t->remote)
 471                                 cmd[k++] = t->remote;
 472                         else
 473                                 cmd[k++] = "-";
 474                 }
 475
 476                 if (t->local)
 477                         cmd[k++] = t->local;
 478                 cmd[k] = NULL;
 479
 480                 execv(cmd[0], (char * const *) cmd);
 481                 log_error_errno(errno, "Failed to execute %s tool: %m", cmd[0]);
 482                 _exit(EXIT_FAILURE);
 483         }
 484
 485         pipefd[1] = safe_close(pipefd[1]);
 486         t->log_fd = TAKE_FD(pipefd[0]);
 487
 488         t->stdin_fd = safe_close(t->stdin_fd);
 489
 490         r = sd_event_add_child(t->manager->event, &t->pid_event_source, t->pid, WEXITED, transfer_on_pid, t);
 491         if (r < 0)
 492                 return r;
 493
 494         r = sd_event_add_io(t->manager->event, &t->log_event_source, t->log_fd, EPOLLIN, transfer_on_log, t);
 495         if (r < 0)
 496                 return r;
 497
 498         /* Make sure always process logging before SIGCHLD */
 499         r = sd_event_source_set_priority(t->log_event_source, SD_EVENT_PRIORITY_NORMAL -5);
 500         if (r < 0)
 501                 return r;
 502
 503         r = sd_bus_emit_signal(
 504                         t->manager->bus,
 505                         "/org/freedesktop/import1",
 506                         "org.freedesktop.import1.Manager",
 507                         "TransferNew",
 508                         "uo",
 509                         t->id,
 510                         t->object_path);
 511         if (r < 0)
 512                 return r;
 513
 514         return 0;
 515 }
 516
 517 static Manager *manager_unref(Manager *m) {
 518         Transfer *t;
 519
 520         if (!m)
 521                 return NULL;
 522
 523         sd_event_source_unref(m->notify_event_source);
 524         safe_close(m->notify_fd);
 525
 526         while ((t = hashmap_first(m->transfers)))
 527                 transfer_unref(t);
 528
 529         hashmap_free(m->transfers);
 530
 531         bus_verify_polkit_async_registry_free(m->polkit_registry);
 532
 533         m->bus = sd_bus_flush_close_unref(m->bus);
 534         sd_event_unref(m->event);
 535
 536         return mfree(m);
 537 }
 538
 539 DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_unref);
 540
 541 static int manager_on_notify(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 542
 543         char buf[NOTIFY_BUFFER_MAX+1];
 544         struct iovec iovec = {
 545                 .iov_base = buf,
 546                 .iov_len = sizeof(buf)-1,
 547         };
 548         union {
 549                 struct cmsghdr cmsghdr;
 550                 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
 551                             CMSG_SPACE(sizeof(int) * NOTIFY_FD_MAX)];
 552         } control = {};
 553         struct msghdr msghdr = {
 554                 .msg_iov = &iovec,
 555                 .msg_iovlen = 1,
 556                 .msg_control = &control,
 557                 .msg_controllen = sizeof(control),
 558         };
 559         struct ucred *ucred = NULL;
 560         Manager *m = userdata;
 561         struct cmsghdr *cmsg;
 562         char *p, *e;
 563         Transfer *t;
 564         Iterator i;
 565         ssize_t n;
 566         int r;
 567
 568         n = recvmsg(fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
 569         if (n < 0) {
 570                 if (IN_SET(errno, EAGAIN, EINTR))
 571                         return 0;
 572
 573                 return -errno;
 574         }
 575
 576         cmsg_close_all(&msghdr);
 577
 578         CMSG_FOREACH(cmsg, &msghdr)
 579                 if (cmsg->cmsg_level == SOL_SOCKET &&
 580                     cmsg->cmsg_type == SCM_CREDENTIALS &&
 581                     cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred)))
 582                         ucred = (struct ucred*) CMSG_DATA(cmsg);
 583
 584         if (msghdr.msg_flags & MSG_TRUNC) {
 585                 log_warning("Got overly long notification datagram, ignoring.");
 586                 return 0;
 587         }
 588
 589         if (!ucred || ucred->pid <= 0) {
 590                 log_warning("Got notification datagram lacking credential information, ignoring.");
 591                 return 0;
 592         }
 593
 594         HASHMAP_FOREACH(t, m->transfers, i)
 595                 if (ucred->pid == t->pid)
 596                         break;
 597
 598         if (!t) {
 599                 log_warning("Got notification datagram from unexpected peer, ignoring.");
 600                 return 0;
 601         }
 602
 603         buf[n] = 0;
 604
 605         p = startswith(buf, "X_IMPORT_PROGRESS=");
 606         if (!p) {
 607                 p = strstr(buf, "\nX_IMPORT_PROGRESS=");
 608                 if (!p)
 609                         return 0;
 610
 611                 p += 19;
 612         }
 613
 614         e = strchrnul(p, '\n');
 615         *e = 0;
 616
 617         r = parse_percent(p);
 618         if (r < 0) {
 619                 log_warning("Got invalid percent value, ignoring.");
 620                 return 0;
 621         }
 622
 623         t->progress_percent = (unsigned) r;
 624
 625         log_debug("Got percentage from client: %u%%", t->progress_percent);
 626         return 0;
 627 }
 628
 629 static int manager_new(Manager **ret) {
 630         _cleanup_(manager_unrefp) Manager *m = NULL;
 631         static const union sockaddr_union sa = {
 632                 .un.sun_family = AF_UNIX,
 633                 .un.sun_path = "/run/systemd/import/notify",
 634         };
 635         int r;
 636
 637         assert(ret);
 638
 639         m = new0(Manager, 1);
 640         if (!m)
 641                 return -ENOMEM;
 642
 643         r = sd_event_default(&m->event);
 644         if (r < 0)
 645                 return r;
 646
 647         sd_event_set_watchdog(m->event, true);
 648
 649         r = sd_bus_default_system(&m->bus);
 650         if (r < 0)
 651                 return r;
 652
 653         m->notify_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
 654         if (m->notify_fd < 0)
 655                 return -errno;
 656
 657         (void) mkdir_parents_label(sa.un.sun_path, 0755);
 658         (void) sockaddr_un_unlink(&sa.un);
 659
 660         if (bind(m->notify_fd, &sa.sa, SOCKADDR_UN_LEN(sa.un)) < 0)
 661                 return -errno;
 662
 663         r = setsockopt_int(m->notify_fd, SOL_SOCKET, SO_PASSCRED, true);
 664         if (r < 0)
 665                 return r;
 666
 667         r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_on_notify, m);
 668         if (r < 0)
 669                 return r;
 670
 671         *ret = TAKE_PTR(m);
 672
 673         return 0;
 674 }
 675
 676 static Transfer *manager_find(Manager *m, TransferType type, const char *remote) {
 677         Transfer *t;
 678         Iterator i;
 679
 680         assert(m);
 681         assert(type >= 0);
 682         assert(type < _TRANSFER_TYPE_MAX);
 683
 684         HASHMAP_FOREACH(t, m->transfers, i)
 685                 if (t->type == type && streq_ptr(t->remote, remote))
 686                         return t;
 687
 688         return NULL;
 689 }
 690
 691 static int method_import_tar_or_raw(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
 692         _cleanup_(transfer_unrefp) Transfer *t = NULL;
 693         int fd, force, read_only, r;
 694         const char *local, *object;
 695         Manager *m = userdata;
 696         TransferType type;
 697         struct stat st;
 698         uint32_t id;
 699
 700         assert(msg);
 701         assert(m);
 702
 703         r = bus_verify_polkit_async(
 704                         msg,
 705                         CAP_SYS_ADMIN,
 706                         "org.freedesktop.import1.import",
 707                         NULL,
 708                         false,
 709                         UID_INVALID,
 710                         &m->polkit_registry,
 711                         error);
 712         if (r < 0)
 713                 return r;
 714         if (r == 0)
 715                 return 1; /* Will call us back */
 716
 717         r = sd_bus_message_read(msg, "hsbb", &fd, &local, &force, &read_only);
 718         if (r < 0)
 719                 return r;
 720
 721         if (fstat(fd, &st) < 0)
 722                 return -errno;
 723
 724         if (!S_ISREG(st.st_mode) && !S_ISFIFO(st.st_mode))
 725                 return -EINVAL;
 726
 727         if (!machine_name_is_valid(local))
 728                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Local name %s is invalid", local);
 729
 730         r = setup_machine_directory(error);
 731         if (r < 0)
 732                 return r;
 733
 734         type = streq_ptr(sd_bus_message_get_member(msg), "ImportTar") ? TRANSFER_IMPORT_TAR : TRANSFER_IMPORT_RAW;
 735
 736         r = transfer_new(m, &t);
 737         if (r < 0)
 738                 return r;
 739
 740         t->type = type;
 741         t->force_local = force;
 742         t->read_only = read_only;
 743
 744         t->local = strdup(local);
 745         if (!t->local)
 746                 return -ENOMEM;
 747
 748         t->stdin_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
 749         if (t->stdin_fd < 0)
 750                 return -errno;
 751
 752         r = transfer_start(t);
 753         if (r < 0)
 754                 return r;
 755
 756         object = t->object_path;
 757         id = t->id;
 758         t = NULL;
 759
 760         return sd_bus_reply_method_return(msg, "uo", id, object);
 761 }
 762
 763 static int method_import_fs(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
 764         _cleanup_(transfer_unrefp) Transfer *t = NULL;
 765         int fd, force, read_only, r;
 766         const char *local, *object;
 767         Manager *m = userdata;
 768         uint32_t id;
 769
 770         assert(msg);
 771         assert(m);
 772
 773         r = bus_verify_polkit_async(
 774                         msg,
 775                         CAP_SYS_ADMIN,
 776                         "org.freedesktop.import1.import",
 777                         NULL,
 778                         false,
 779                         UID_INVALID,
 780                         &m->polkit_registry,
 781                         error);
 782         if (r < 0)
 783                 return r;
 784         if (r == 0)
 785                 return 1; /* Will call us back */
 786
 787         r = sd_bus_message_read(msg, "hsbb", &fd, &local, &force, &read_only);
 788         if (r < 0)
 789                 return r;
 790
 791         r = fd_verify_directory(fd);
 792         if (r < 0)
 793                 return r;
 794
 795         if (!machine_name_is_valid(local))
 796                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Local name %s is invalid", local);
 797
 798         r = setup_machine_directory(error);
 799         if (r < 0)
 800                 return r;
 801
 802         r = transfer_new(m, &t);
 803         if (r < 0)
 804                 return r;
 805
 806         t->type = TRANSFER_IMPORT_FS;
 807         t->force_local = force;
 808         t->read_only = read_only;
 809
 810         t->local = strdup(local);
 811         if (!t->local)
 812                 return -ENOMEM;
 813
 814         t->stdin_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
 815         if (t->stdin_fd < 0)
 816                 return -errno;
 817
 818         r = transfer_start(t);
 819         if (r < 0)
 820                 return r;
 821
 822         object = t->object_path;
 823         id = t->id;
 824         t = NULL;
 825
 826         return sd_bus_reply_method_return(msg, "uo", id, object);
 827 }
 828
 829 static int method_export_tar_or_raw(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
 830         _cleanup_(transfer_unrefp) Transfer *t = NULL;
 831         int fd, r;
 832         const char *local, *object, *format;
 833         Manager *m = userdata;
 834         TransferType type;
 835         struct stat st;
 836         uint32_t id;
 837
 838         assert(msg);
 839         assert(m);
 840
 841         r = bus_verify_polkit_async(
 842                         msg,
 843                         CAP_SYS_ADMIN,
 844                         "org.freedesktop.import1.export",
 845                         NULL,
 846                         false,
 847                         UID_INVALID,
 848                         &m->polkit_registry,
 849                         error);
 850         if (r < 0)
 851                 return r;
 852         if (r == 0)
 853                 return 1; /* Will call us back */
 854
 855         r = sd_bus_message_read(msg, "shs", &local, &fd, &format);
 856         if (r < 0)
 857                 return r;
 858
 859         if (!machine_name_is_valid(local))
 860                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Local name %s is invalid", local);
 861
 862         if (fstat(fd, &st) < 0)
 863                 return -errno;
 864
 865         if (!S_ISREG(st.st_mode) && !S_ISFIFO(st.st_mode))
 866                 return -EINVAL;
 867
 868         type = streq_ptr(sd_bus_message_get_member(msg), "ExportTar") ? TRANSFER_EXPORT_TAR : TRANSFER_EXPORT_RAW;
 869
 870         r = transfer_new(m, &t);
 871         if (r < 0)
 872                 return r;
 873
 874         t->type = type;
 875
 876         if (!isempty(format)) {
 877                 t->format = strdup(format);
 878                 if (!t->format)
 879                         return -ENOMEM;
 880         }
 881
 882         t->local = strdup(local);
 883         if (!t->local)
 884                 return -ENOMEM;
 885
 886         t->stdout_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
 887         if (t->stdout_fd < 0)
 888                 return -errno;
 889
 890         r = transfer_start(t);
 891         if (r < 0)
 892                 return r;
 893
 894         object = t->object_path;
 895         id = t->id;
 896         t = NULL;
 897
 898         return sd_bus_reply_method_return(msg, "uo", id, object);
 899 }
 900
 901 static int method_pull_tar_or_raw(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
 902         _cleanup_(transfer_unrefp) Transfer *t = NULL;
 903         const char *remote, *local, *verify, *object;
 904         Manager *m = userdata;
 905         ImportVerify v;
 906         TransferType type;
 907         int force, r;
 908         uint32_t id;
 909
 910         assert(msg);
 911         assert(m);
 912
 913         r = bus_verify_polkit_async(
 914                         msg,
 915                         CAP_SYS_ADMIN,
 916                         "org.freedesktop.import1.pull",
 917                         NULL,
 918                         false,
 919                         UID_INVALID,
 920                         &m->polkit_registry,
 921                         error);
 922         if (r < 0)
 923                 return r;
 924         if (r == 0)
 925                 return 1; /* Will call us back */
 926
 927         r = sd_bus_message_read(msg, "sssb", &remote, &local, &verify, &force);
 928         if (r < 0)
 929                 return r;
 930
 931         if (!http_url_is_valid(remote))
 932                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "URL %s is invalid", remote);
 933
 934         if (isempty(local))
 935                 local = NULL;
 936         else if (!machine_name_is_valid(local))
 937                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Local name %s is invalid", local);
 938
 939         if (isempty(verify))
 940                 v = IMPORT_VERIFY_SIGNATURE;
 941         else
 942                 v = import_verify_from_string(verify);
 943         if (v < 0)
 944                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown verification mode %s", verify);
 945
 946         r = setup_machine_directory(error);
 947         if (r < 0)
 948                 return r;
 949
 950         type = streq_ptr(sd_bus_message_get_member(msg), "PullTar") ? TRANSFER_PULL_TAR : TRANSFER_PULL_RAW;
 951
 952         if (manager_find(m, type, remote))
 953                 return sd_bus_error_setf(error, BUS_ERROR_TRANSFER_IN_PROGRESS, "Transfer for %s already in progress.", remote);
 954
 955         r = transfer_new(m, &t);
 956         if (r < 0)
 957                 return r;
 958
 959         t->type = type;
 960         t->verify = v;
 961         t->force_local = force;
 962
 963         t->remote = strdup(remote);
 964         if (!t->remote)
 965                 return -ENOMEM;
 966
 967         if (local) {
 968                 t->local = strdup(local);
 969                 if (!t->local)
 970                         return -ENOMEM;
 971         }
 972
 973         r = transfer_start(t);
 974         if (r < 0)
 975                 return r;
 976
 977         object = t->object_path;
 978         id = t->id;
 979         t = NULL;
 980
 981         return sd_bus_reply_method_return(msg, "uo", id, object);
 982 }
 983
 984 static int method_list_transfers(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
 985         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 986         Manager *m = userdata;
 987         Transfer *t;
 988         Iterator i;
 989         int r;
 990
 991         assert(msg);
 992         assert(m);
 993
 994         r = sd_bus_message_new_method_return(msg, &reply);
 995         if (r < 0)
 996                 return r;
 997
 998         r = sd_bus_message_open_container(reply, 'a', "(usssdo)");
 999         if (r < 0)
1000                 return r;
1001
1002         HASHMAP_FOREACH(t, m->transfers, i) {
1003
1004                 r = sd_bus_message_append(
1005                                 reply,
1006                                 "(usssdo)",
1007                                 t->id,
1008                                 transfer_type_to_string(t->type),
1009                                 t->remote,
1010                                 t->local,
1011                                 transfer_percent_as_double(t),
1012                                 t->object_path);
1013                 if (r < 0)
1014                         return r;
1015         }
1016
1017         r = sd_bus_message_close_container(reply);
1018         if (r < 0)
1019                 return r;
1020
1021         return sd_bus_send(NULL, reply, NULL);
1022 }
1023
1024 static int method_cancel(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
1025         Transfer *t = userdata;
1026         int r;
1027
1028         assert(msg);
1029         assert(t);
1030
1031         r = bus_verify_polkit_async(
1032                         msg,
1033                         CAP_SYS_ADMIN,
1034                         "org.freedesktop.import1.pull",
1035                         NULL,
1036                         false,
1037                         UID_INVALID,
1038                         &t->manager->polkit_registry,
1039                         error);
1040         if (r < 0)
1041                 return r;
1042         if (r == 0)
1043                 return 1; /* Will call us back */
1044
1045         r = transfer_cancel(t);
1046         if (r < 0)
1047                 return r;
1048
1049         return sd_bus_reply_method_return(msg, NULL);
1050 }
1051
1052 static int method_cancel_transfer(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
1053         Manager *m = userdata;
1054         Transfer *t;
1055         uint32_t id;
1056         int r;
1057
1058         assert(msg);
1059         assert(m);
1060
1061         r = bus_verify_polkit_async(
1062                         msg,
1063                         CAP_SYS_ADMIN,
1064                         "org.freedesktop.import1.pull",
1065                         NULL,
1066                         false,
1067                         UID_INVALID,
1068                         &m->polkit_registry,
1069                         error);
1070         if (r < 0)
1071                 return r;
1072         if (r == 0)
1073                 return 1; /* Will call us back */
1074
1075         r = sd_bus_message_read(msg, "u", &id);
1076         if (r < 0)
1077                 return r;
1078         if (id <= 0)
1079                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid transfer id");
1080
1081         t = hashmap_get(m->transfers, UINT32_TO_PTR(id));
1082         if (!t)
1083                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_TRANSFER, "No transfer by id %" PRIu32, id);
1084
1085         r = transfer_cancel(t);
1086         if (r < 0)
1087                 return r;
1088
1089         return sd_bus_reply_method_return(msg, NULL);
1090 }
1091
1092 static int property_get_progress(
1093                 sd_bus *bus,
1094                 const char *path,
1095                 const char *interface,
1096                 const char *property,
1097                 sd_bus_message *reply,
1098                 void *userdata,
1099                 sd_bus_error *error) {
1100
1101         Transfer *t = userdata;
1102
1103         assert(bus);
1104         assert(reply);
1105         assert(t);
1106
1107         return sd_bus_message_append(reply, "d", transfer_percent_as_double(t));
1108 }
1109
1110 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_type, transfer_type, TransferType);
1111 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_verify, import_verify, ImportVerify);
1112
1113 static const sd_bus_vtable transfer_vtable[] = {
1114         SD_BUS_VTABLE_START(0),
1115         SD_BUS_PROPERTY("Id", "u", NULL, offsetof(Transfer, id), SD_BUS_VTABLE_PROPERTY_CONST),
1116         SD_BUS_PROPERTY("Local", "s", NULL, offsetof(Transfer, local), SD_BUS_VTABLE_PROPERTY_CONST),
1117         SD_BUS_PROPERTY("Remote", "s", NULL, offsetof(Transfer, remote), SD_BUS_VTABLE_PROPERTY_CONST),
1118         SD_BUS_PROPERTY("Type", "s", property_get_type, offsetof(Transfer, type), SD_BUS_VTABLE_PROPERTY_CONST),
1119         SD_BUS_PROPERTY("Verify", "s", property_get_verify, offsetof(Transfer, verify), SD_BUS_VTABLE_PROPERTY_CONST),
1120         SD_BUS_PROPERTY("Progress", "d", property_get_progress, 0, 0),
1121         SD_BUS_METHOD("Cancel", NULL, NULL, method_cancel, SD_BUS_VTABLE_UNPRIVILEGED),
1122         SD_BUS_SIGNAL("LogMessage", "us", 0),
1123         SD_BUS_VTABLE_END,
1124 };
1125
1126 static const sd_bus_vtable manager_vtable[] = {
1127         SD_BUS_VTABLE_START(0),
1128         SD_BUS_METHOD("ImportTar", "hsbb", "uo", method_import_tar_or_raw, SD_BUS_VTABLE_UNPRIVILEGED),
1129         SD_BUS_METHOD("ImportRaw", "hsbb", "uo", method_import_tar_or_raw, SD_BUS_VTABLE_UNPRIVILEGED),
1130         SD_BUS_METHOD("ImportFileSystem", "hsbb", "uo", method_import_fs, SD_BUS_VTABLE_UNPRIVILEGED),
1131         SD_BUS_METHOD("ExportTar", "shs", "uo", method_export_tar_or_raw, SD_BUS_VTABLE_UNPRIVILEGED),
1132         SD_BUS_METHOD("ExportRaw", "shs", "uo", method_export_tar_or_raw, SD_BUS_VTABLE_UNPRIVILEGED),
1133         SD_BUS_METHOD("PullTar", "sssb", "uo", method_pull_tar_or_raw, SD_BUS_VTABLE_UNPRIVILEGED),
1134         SD_BUS_METHOD("PullRaw", "sssb", "uo", method_pull_tar_or_raw, SD_BUS_VTABLE_UNPRIVILEGED),
1135         SD_BUS_METHOD("ListTransfers", NULL, "a(usssdo)", method_list_transfers, SD_BUS_VTABLE_UNPRIVILEGED),
1136         SD_BUS_METHOD("CancelTransfer", "u", NULL, method_cancel_transfer, SD_BUS_VTABLE_UNPRIVILEGED),
1137         SD_BUS_SIGNAL("TransferNew", "uo", 0),
1138         SD_BUS_SIGNAL("TransferRemoved", "uos", 0),
1139         SD_BUS_VTABLE_END,
1140 };
1141
1142 static int transfer_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
1143         Manager *m = userdata;
1144         Transfer *t;
1145         const char *p;
1146         uint32_t id;
1147         int r;
1148
1149         assert(bus);
1150         assert(path);
1151         assert(interface);
1152         assert(found);
1153         assert(m);
1154
1155         p = startswith(path, "/org/freedesktop/import1/transfer/_");
1156         if (!p)
1157                 return 0;
1158
1159         r = safe_atou32(p, &id);
1160         if (r < 0 || id == 0)
1161                 return 0;
1162
1163         t = hashmap_get(m->transfers, UINT32_TO_PTR(id));
1164         if (!t)
1165                 return 0;
1166
1167         *found = t;
1168         return 1;
1169 }
1170
1171 static int transfer_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
1172         _cleanup_strv_free_ char **l = NULL;
1173         Manager *m = userdata;
1174         Transfer *t;
1175         unsigned k = 0;
1176         Iterator i;
1177
1178         l = new0(char*, hashmap_size(m->transfers) + 1);
1179         if (!l)
1180                 return -ENOMEM;
1181
1182         HASHMAP_FOREACH(t, m->transfers, i) {
1183
1184                 l[k] = strdup(t->object_path);
1185                 if (!l[k])
1186                         return -ENOMEM;
1187
1188                 k++;
1189         }
1190
1191         *nodes = TAKE_PTR(l);
1192
1193         return 1;
1194 }
1195
1196 static int manager_add_bus_objects(Manager *m) {
1197         int r;
1198
1199         assert(m);
1200
1201         r = sd_bus_add_object_vtable(m->bus, NULL, "/org/freedesktop/import1", "org.freedesktop.import1.Manager", manager_vtable, m);
1202         if (r < 0)
1203                 return log_error_errno(r, "Failed to register object: %m");
1204
1205         r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/import1/transfer", "org.freedesktop.import1.Transfer", transfer_vtable, transfer_object_find, m);
1206         if (r < 0)
1207                 return log_error_errno(r, "Failed to register object: %m");
1208
1209         r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/import1/transfer", transfer_node_enumerator, m);
1210         if (r < 0)
1211                 return log_error_errno(r, "Failed to add transfer enumerator: %m");
1212
1213         r = sd_bus_request_name_async(m->bus, NULL, "org.freedesktop.import1", 0, NULL, NULL);
1214         if (r < 0)
1215                 return log_error_errno(r, "Failed to request name: %m");
1216
1217         r = sd_bus_attach_event(m->bus, m->event, 0);
1218         if (r < 0)
1219                 return log_error_errno(r, "Failed to attach bus to event loop: %m");
1220
1221         return 0;
1222 }
1223
1224 static bool manager_check_idle(void *userdata) {
1225         Manager *m = userdata;
1226
1227         return hashmap_isempty(m->transfers);
1228 }
1229
1230 static int manager_run(Manager *m) {
1231         assert(m);
1232
1233         return bus_event_loop_with_idle(
1234                         m->event,
1235                         m->bus,
1236                         "org.freedesktop.import1",
1237                         DEFAULT_EXIT_USEC,
1238                         manager_check_idle,
1239                         m);
1240 }
1241
1242 static int run(int argc, char *argv[]) {
1243         _cleanup_(manager_unrefp) Manager *m = NULL;
1244         int r;
1245
1246         log_setup_service();
1247
1248         umask(0022);
1249
1250         if (argc != 1) {
1251                 log_error("This program takes no arguments.");
1252                 return -EINVAL;
1253         }
1254
1255         assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGCHLD, -1) >= 0);
1256
1257         r = manager_new(&m);
1258         if (r < 0)
1259                 return log_error_errno(r, "Failed to allocate manager object: %m");
1260
1261         r = manager_add_bus_objects(m);
1262         if (r < 0)
1263                 return r;
1264
1265         r = manager_run(m);
1266         if (r < 0)
1267                 return log_error_errno(r, "Failed to run event loop: %m");
1268
1269         return 0;
1270 }
1271
1272 DEFINE_MAIN_FUNCTION(run);