src/machine/image-dbus.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2014 Lennart Poettering
   6 ***/
   7
   8 #include <sys/file.h>
   9 #include <sys/mount.h>
  10
  11 #include "alloc-util.h"
  12 #include "bus-label.h"
  13 #include "bus-util.h"
  14 #include "copy.h"
  15 #include "dissect-image.h"
  16 #include "fd-util.h"
  17 #include "fileio.h"
  18 #include "fs-util.h"
  19 #include "image-dbus.h"
  20 #include "io-util.h"
  21 #include "loop-util.h"
  22 #include "machine-image.h"
  23 #include "mount-util.h"
  24 #include "process-util.h"
  25 #include "raw-clone.h"
  26 #include "strv.h"
  27 #include "user-util.h"
  28
  29 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_type, image_type, ImageType);
  30
  31 int bus_image_method_remove(
  32                 sd_bus_message *message,
  33                 void *userdata,
  34                 sd_bus_error *error) {
  35
  36         _cleanup_close_pair_ int errno_pipe_fd[2] = { -1, -1 };
  37         Image *image = userdata;
  38         Manager *m = image->userdata;
  39         pid_t child;
  40         int r;
  41
  42         assert(message);
  43         assert(image);
  44
  45         if (m->n_operations >= OPERATIONS_MAX)
  46                 return sd_bus_error_setf(error, SD_BUS_ERROR_LIMITS_EXCEEDED, "Too many ongoing operations.");
  47
  48         r = bus_verify_polkit_async(
  49                         message,
  50                         CAP_SYS_ADMIN,
  51                         "org.freedesktop.machine1.manage-images",
  52                         NULL,
  53                         false,
  54                         UID_INVALID,
  55                         &m->polkit_registry,
  56                         error);
  57         if (r < 0)
  58                 return r;
  59         if (r == 0)
  60                 return 1; /* Will call us back */
  61
  62         if (pipe2(errno_pipe_fd, O_CLOEXEC|O_NONBLOCK) < 0)
  63                 return sd_bus_error_set_errnof(error, errno, "Failed to create pipe: %m");
  64
  65         r = safe_fork("(sd-imgrm)", FORK_RESET_SIGNALS, &child);
  66         if (r < 0)
  67                 return sd_bus_error_set_errnof(error, r, "Failed to fork(): %m");
  68         if (r == 0) {
  69                 errno_pipe_fd[0] = safe_close(errno_pipe_fd[0]);
  70
  71                 r = image_remove(image);
  72                 if (r < 0) {
  73                         (void) write(errno_pipe_fd[1], &r, sizeof(r));
  74                         _exit(EXIT_FAILURE);
  75                 }
  76
  77                 _exit(EXIT_SUCCESS);
  78         }
  79
  80         errno_pipe_fd[1] = safe_close(errno_pipe_fd[1]);
  81
  82         r = operation_new(m, NULL, child, message, errno_pipe_fd[0], NULL);
  83         if (r < 0) {
  84                 (void) sigkill_wait(child);
  85                 return r;
  86         }
  87
  88         errno_pipe_fd[0] = -1;
  89
  90         return 1;
  91 }
  92
  93 int bus_image_method_rename(
  94                 sd_bus_message *message,
  95                 void *userdata,
  96                 sd_bus_error *error) {
  97
  98         Image *image = userdata;
  99         Manager *m = image->userdata;
 100         const char *new_name;
 101         int r;
 102
 103         assert(message);
 104         assert(image);
 105
 106         r = sd_bus_message_read(message, "s", &new_name);
 107         if (r < 0)
 108                 return r;
 109
 110         if (!image_name_is_valid(new_name))
 111                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Image name '%s' is invalid.", new_name);
 112
 113         r = bus_verify_polkit_async(
 114                         message,
 115                         CAP_SYS_ADMIN,
 116                         "org.freedesktop.machine1.manage-images",
 117                         NULL,
 118                         false,
 119                         UID_INVALID,
 120                         &m->polkit_registry,
 121                         error);
 122         if (r < 0)
 123                 return r;
 124         if (r == 0)
 125                 return 1; /* Will call us back */
 126
 127         r = image_rename(image, new_name);
 128         if (r < 0)
 129                 return r;
 130
 131         return sd_bus_reply_method_return(message, NULL);
 132 }
 133
 134 int bus_image_method_clone(
 135                 sd_bus_message *message,
 136                 void *userdata,
 137                 sd_bus_error *error) {
 138
 139         _cleanup_close_pair_ int errno_pipe_fd[2] = { -1, -1 };
 140         Image *image = userdata;
 141         Manager *m = image->userdata;
 142         const char *new_name;
 143         int r, read_only;
 144         pid_t child;
 145
 146         assert(message);
 147         assert(image);
 148         assert(m);
 149
 150         if (m->n_operations >= OPERATIONS_MAX)
 151                 return sd_bus_error_setf(error, SD_BUS_ERROR_LIMITS_EXCEEDED, "Too many ongoing operations.");
 152
 153         r = sd_bus_message_read(message, "sb", &new_name, &read_only);
 154         if (r < 0)
 155                 return r;
 156
 157         if (!image_name_is_valid(new_name))
 158                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Image name '%s' is invalid.", new_name);
 159
 160         r = bus_verify_polkit_async(
 161                         message,
 162                         CAP_SYS_ADMIN,
 163                         "org.freedesktop.machine1.manage-images",
 164                         NULL,
 165                         false,
 166                         UID_INVALID,
 167                         &m->polkit_registry,
 168                         error);
 169         if (r < 0)
 170                 return r;
 171         if (r == 0)
 172                 return 1; /* Will call us back */
 173
 174         if (pipe2(errno_pipe_fd, O_CLOEXEC|O_NONBLOCK) < 0)
 175                 return sd_bus_error_set_errnof(error, errno, "Failed to create pipe: %m");
 176
 177         r = safe_fork("(imgclone)", FORK_RESET_SIGNALS, &child);
 178         if (r < 0)
 179                 return sd_bus_error_set_errnof(error, r, "Failed to fork(): %m");
 180         if (r == 0) {
 181                 errno_pipe_fd[0] = safe_close(errno_pipe_fd[0]);
 182
 183                 r = image_clone(image, new_name, read_only);
 184                 if (r < 0) {
 185                         (void) write(errno_pipe_fd[1], &r, sizeof(r));
 186                         _exit(EXIT_FAILURE);
 187                 }
 188
 189                 _exit(EXIT_SUCCESS);
 190         }
 191
 192         errno_pipe_fd[1] = safe_close(errno_pipe_fd[1]);
 193
 194         r = operation_new(m, NULL, child, message, errno_pipe_fd[0], NULL);
 195         if (r < 0) {
 196                 (void) sigkill_wait(child);
 197                 return r;
 198         }
 199
 200         errno_pipe_fd[0] = -1;
 201
 202         return 1;
 203 }
 204
 205 int bus_image_method_mark_read_only(
 206                 sd_bus_message *message,
 207                 void *userdata,
 208                 sd_bus_error *error) {
 209
 210         Image *image = userdata;
 211         Manager *m = image->userdata;
 212         int r, read_only;
 213
 214         assert(message);
 215
 216         r = sd_bus_message_read(message, "b", &read_only);
 217         if (r < 0)
 218                 return r;
 219
 220         r = bus_verify_polkit_async(
 221                         message,
 222                         CAP_SYS_ADMIN,
 223                         "org.freedesktop.machine1.manage-images",
 224                         NULL,
 225                         false,
 226                         UID_INVALID,
 227                         &m->polkit_registry,
 228                         error);
 229         if (r < 0)
 230                 return r;
 231         if (r == 0)
 232                 return 1; /* Will call us back */
 233
 234         r = image_read_only(image, read_only);
 235         if (r < 0)
 236                 return r;
 237
 238         return sd_bus_reply_method_return(message, NULL);
 239 }
 240
 241 int bus_image_method_set_limit(
 242                 sd_bus_message *message,
 243                 void *userdata,
 244                 sd_bus_error *error) {
 245
 246         Image *image = userdata;
 247         Manager *m = image->userdata;
 248         uint64_t limit;
 249         int r;
 250
 251         assert(message);
 252
 253         r = sd_bus_message_read(message, "t", &limit);
 254         if (r < 0)
 255                 return r;
 256         if (!FILE_SIZE_VALID_OR_INFINITY(limit))
 257                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "New limit out of range");
 258
 259         r = bus_verify_polkit_async(
 260                         message,
 261                         CAP_SYS_ADMIN,
 262                         "org.freedesktop.machine1.manage-images",
 263                         NULL,
 264                         false,
 265                         UID_INVALID,
 266                         &m->polkit_registry,
 267                         error);
 268         if (r < 0)
 269                 return r;
 270         if (r == 0)
 271                 return 1; /* Will call us back */
 272
 273         r = image_set_limit(image, limit);
 274         if (r < 0)
 275                 return r;
 276
 277         return sd_bus_reply_method_return(message, NULL);
 278 }
 279
 280 int bus_image_method_get_hostname(
 281                 sd_bus_message *message,
 282                 void *userdata,
 283                 sd_bus_error *error) {
 284
 285         Image *image = userdata;
 286         int r;
 287
 288         if (!image->metadata_valid) {
 289                 r = image_read_metadata(image);
 290                 if (r < 0)
 291                         return sd_bus_error_set_errnof(error, r, "Failed to read image metadata: %m");
 292         }
 293
 294         return sd_bus_reply_method_return(message, "s", image->hostname);
 295 }
 296
 297 int bus_image_method_get_machine_id(
 298                 sd_bus_message *message,
 299                 void *userdata,
 300                 sd_bus_error *error) {
 301
 302         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 303         Image *image = userdata;
 304         int r;
 305
 306         if (!image->metadata_valid) {
 307                 r = image_read_metadata(image);
 308                 if (r < 0)
 309                         return sd_bus_error_set_errnof(error, r, "Failed to read image metadata: %m");
 310         }
 311
 312         r = sd_bus_message_new_method_return(message, &reply);
 313         if (r < 0)
 314                 return r;
 315
 316         if (sd_id128_is_null(image->machine_id)) /* Add an empty array if the ID is zero */
 317                 r = sd_bus_message_append(reply, "ay", 0);
 318         else
 319                 r = sd_bus_message_append_array(reply, 'y', image->machine_id.bytes, 16);
 320         if (r < 0)
 321                 return r;
 322
 323         return sd_bus_send(NULL, reply, NULL);
 324 }
 325
 326 int bus_image_method_get_machine_info(
 327                 sd_bus_message *message,
 328                 void *userdata,
 329                 sd_bus_error *error) {
 330
 331         Image *image = userdata;
 332         int r;
 333
 334         if (!image->metadata_valid) {
 335                 r = image_read_metadata(image);
 336                 if (r < 0)
 337                         return sd_bus_error_set_errnof(error, r, "Failed to read image metadata: %m");
 338         }
 339
 340         return bus_reply_pair_array(message, image->machine_info);
 341 }
 342
 343 int bus_image_method_get_os_release(
 344                 sd_bus_message *message,
 345                 void *userdata,
 346                 sd_bus_error *error) {
 347
 348         Image *image = userdata;
 349         int r;
 350
 351         if (!image->metadata_valid) {
 352                 r = image_read_metadata(image);
 353                 if (r < 0)
 354                         return sd_bus_error_set_errnof(error, r, "Failed to read image metadata: %m");
 355         }
 356
 357         return bus_reply_pair_array(message, image->os_release);
 358 }
 359
 360 const sd_bus_vtable image_vtable[] = {
 361         SD_BUS_VTABLE_START(0),
 362         SD_BUS_PROPERTY("Name", "s", NULL, offsetof(Image, name), 0),
 363         SD_BUS_PROPERTY("Path", "s", NULL, offsetof(Image, path), 0),
 364         SD_BUS_PROPERTY("Type", "s", property_get_type,  offsetof(Image, type), 0),
 365         SD_BUS_PROPERTY("ReadOnly", "b", bus_property_get_bool, offsetof(Image, read_only), 0),
 366         SD_BUS_PROPERTY("CreationTimestamp", "t", NULL, offsetof(Image, crtime), 0),
 367         SD_BUS_PROPERTY("ModificationTimestamp", "t", NULL, offsetof(Image, mtime), 0),
 368         SD_BUS_PROPERTY("Usage", "t", NULL, offsetof(Image, usage), 0),
 369         SD_BUS_PROPERTY("Limit", "t", NULL, offsetof(Image, limit), 0),
 370         SD_BUS_PROPERTY("UsageExclusive", "t", NULL, offsetof(Image, usage_exclusive), 0),
 371         SD_BUS_PROPERTY("LimitExclusive", "t", NULL, offsetof(Image, limit_exclusive), 0),
 372         SD_BUS_METHOD("Remove", NULL, NULL, bus_image_method_remove, SD_BUS_VTABLE_UNPRIVILEGED),
 373         SD_BUS_METHOD("Rename", "s", NULL, bus_image_method_rename, SD_BUS_VTABLE_UNPRIVILEGED),
 374         SD_BUS_METHOD("Clone", "sb", NULL, bus_image_method_clone, SD_BUS_VTABLE_UNPRIVILEGED),
 375         SD_BUS_METHOD("MarkReadOnly", "b", NULL, bus_image_method_mark_read_only, SD_BUS_VTABLE_UNPRIVILEGED),
 376         SD_BUS_METHOD("SetLimit", "t", NULL, bus_image_method_set_limit, SD_BUS_VTABLE_UNPRIVILEGED),
 377         SD_BUS_METHOD("GetHostname", NULL, "s", bus_image_method_get_hostname, SD_BUS_VTABLE_UNPRIVILEGED),
 378         SD_BUS_METHOD("GetMachineID", NULL, "ay", bus_image_method_get_machine_id, SD_BUS_VTABLE_UNPRIVILEGED),
 379         SD_BUS_METHOD("GetMachineInfo", NULL, "a{ss}", bus_image_method_get_machine_info, SD_BUS_VTABLE_UNPRIVILEGED),
 380         SD_BUS_METHOD("GetOSRelease", NULL, "a{ss}", bus_image_method_get_os_release, SD_BUS_VTABLE_UNPRIVILEGED),
 381         SD_BUS_VTABLE_END
 382 };
 383
 384 static int image_flush_cache(sd_event_source *s, void *userdata) {
 385         Manager *m = userdata;
 386
 387         assert(s);
 388         assert(m);
 389
 390         hashmap_clear_with_destructor(m->image_cache, image_unref);
 391         return 0;
 392 }
 393
 394 int image_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
 395         _cleanup_free_ char *e = NULL;
 396         Manager *m = userdata;
 397         Image *image = NULL;
 398         const char *p;
 399         int r;
 400
 401         assert(bus);
 402         assert(path);
 403         assert(interface);
 404         assert(found);
 405
 406         p = startswith(path, "/org/freedesktop/machine1/image/");
 407         if (!p)
 408                 return 0;
 409
 410         e = bus_label_unescape(p);
 411         if (!e)
 412                 return -ENOMEM;
 413
 414         image = hashmap_get(m->image_cache, e);
 415         if (image) {
 416                 *found = image;
 417                 return 1;
 418         }
 419
 420         r = hashmap_ensure_allocated(&m->image_cache, &string_hash_ops);
 421         if (r < 0)
 422                 return r;
 423
 424         if (!m->image_cache_defer_event) {
 425                 r = sd_event_add_defer(m->event, &m->image_cache_defer_event, image_flush_cache, m);
 426                 if (r < 0)
 427                         return r;
 428
 429                 r = sd_event_source_set_priority(m->image_cache_defer_event, SD_EVENT_PRIORITY_IDLE);
 430                 if (r < 0)
 431                         return r;
 432         }
 433
 434         r = sd_event_source_set_enabled(m->image_cache_defer_event, SD_EVENT_ONESHOT);
 435         if (r < 0)
 436                 return r;
 437
 438         r = image_find(IMAGE_MACHINE, e, &image);
 439         if (r <= 0)
 440                 return r;
 441
 442         image->userdata = m;
 443
 444         r = hashmap_put(m->image_cache, image->name, image);
 445         if (r < 0) {
 446                 image_unref(image);
 447                 return r;
 448         }
 449
 450         *found = image;
 451         return 1;
 452 }
 453
 454 char *image_bus_path(const char *name) {
 455         _cleanup_free_ char *e = NULL;
 456
 457         assert(name);
 458
 459         e = bus_label_escape(name);
 460         if (!e)
 461                 return NULL;
 462
 463         return strappend("/org/freedesktop/machine1/image/", e);
 464 }
 465
 466 int image_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
 467         _cleanup_(image_hashmap_freep) Hashmap *images = NULL;
 468         _cleanup_strv_free_ char **l = NULL;
 469         Image *image;
 470         Iterator i;
 471         int r;
 472
 473         assert(bus);
 474         assert(path);
 475         assert(nodes);
 476
 477         images = hashmap_new(&string_hash_ops);
 478         if (!images)
 479                 return -ENOMEM;
 480
 481         r = image_discover(IMAGE_MACHINE, images);
 482         if (r < 0)
 483                 return r;
 484
 485         HASHMAP_FOREACH(image, images, i) {
 486                 char *p;
 487
 488                 p = image_bus_path(image->name);
 489                 if (!p)
 490                         return -ENOMEM;
 491
 492                 r = strv_consume(&l, p);
 493                 if (r < 0)
 494                         return r;
 495         }
 496
 497         *nodes = TAKE_PTR(l);
 498
 499         return 1;
 500 }