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