src/machine/image-dbus.c

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