src/portable/portabled-bus.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include "alloc-util.h"
   4 #include "btrfs-util.h"
   5 #include "bus-common-errors.h"
   6 #include "bus-util.h"
   7 #include "fd-util.h"
   8 #include "io-util.h"
   9 #include "machine-image.h"
  10 #include "missing_capability.h"
  11 #include "portable.h"
  12 #include "portabled-bus.h"
  13 #include "portabled-image-bus.h"
  14 #include "portabled-image.h"
  15 #include "portabled.h"
  16 #include "strv.h"
  17 #include "user-util.h"
  18
  19 static int property_get_pool_path(
  20                 sd_bus *bus,
  21                 const char *path,
  22                 const char *interface,
  23                 const char *property,
  24                 sd_bus_message *reply,
  25                 void *userdata,
  26                 sd_bus_error *error) {
  27
  28         assert(bus);
  29         assert(reply);
  30
  31         return sd_bus_message_append(reply, "s", "/var/lib/portables");
  32 }
  33
  34 static int property_get_pool_usage(
  35                 sd_bus *bus,
  36                 const char *path,
  37                 const char *interface,
  38                 const char *property,
  39                 sd_bus_message *reply,
  40                 void *userdata,
  41                 sd_bus_error *error) {
  42
  43         _cleanup_close_ int fd = -1;
  44         uint64_t usage = (uint64_t) -1;
  45
  46         assert(bus);
  47         assert(reply);
  48
  49         fd = open("/var/lib/portables", O_RDONLY|O_CLOEXEC|O_DIRECTORY);
  50         if (fd >= 0) {
  51                 BtrfsQuotaInfo q;
  52
  53                 if (btrfs_subvol_get_subtree_quota_fd(fd, 0, &q) >= 0)
  54                         usage = q.referenced;
  55         }
  56
  57         return sd_bus_message_append(reply, "t", usage);
  58 }
  59
  60 static int property_get_pool_limit(
  61                 sd_bus *bus,
  62                 const char *path,
  63                 const char *interface,
  64                 const char *property,
  65                 sd_bus_message *reply,
  66                 void *userdata,
  67                 sd_bus_error *error) {
  68
  69         _cleanup_close_ int fd = -1;
  70         uint64_t size = (uint64_t) -1;
  71
  72         assert(bus);
  73         assert(reply);
  74
  75         fd = open("/var/lib/portables", O_RDONLY|O_CLOEXEC|O_DIRECTORY);
  76         if (fd >= 0) {
  77                 BtrfsQuotaInfo q;
  78
  79                 if (btrfs_subvol_get_subtree_quota_fd(fd, 0, &q) >= 0)
  80                         size = q.referenced_max;
  81         }
  82
  83         return sd_bus_message_append(reply, "t", size);
  84 }
  85
  86 static int property_get_profiles(
  87                 sd_bus *bus,
  88                 const char *path,
  89                 const char *interface,
  90                 const char *property,
  91                 sd_bus_message *reply,
  92                 void *userdata,
  93                 sd_bus_error *error) {
  94
  95         _cleanup_strv_free_ char **l = NULL;
  96         int r;
  97
  98         assert(bus);
  99         assert(reply);
 100
 101         r = portable_get_profiles(&l);
 102         if (r < 0)
 103                 return r;
 104
 105         return sd_bus_message_append_strv(reply, l);
 106 }
 107
 108 static int method_get_image(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 109         _cleanup_free_ char *p = NULL;
 110         Manager *m = userdata;
 111         const char *name;
 112         Image *image;
 113         int r;
 114
 115         assert(message);
 116         assert(m);
 117
 118         r = sd_bus_message_read(message, "s", &name);
 119         if (r < 0)
 120                 return r;
 121
 122         r = bus_image_acquire(m, message, name, NULL, BUS_IMAGE_REFUSE_BY_PATH, NULL, &image, error);
 123         if (r < 0)
 124                 return r;
 125
 126         r = bus_image_path(image, &p);
 127         if (r < 0)
 128                 return r;
 129
 130         return sd_bus_reply_method_return(message, "o", p);
 131 }
 132
 133 static int method_list_images(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 134         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 135         _cleanup_hashmap_free_ Hashmap *images = NULL;
 136         Manager *m = userdata;
 137         Image *image;
 138         Iterator i;
 139         int r;
 140
 141         assert(message);
 142         assert(m);
 143
 144         images = hashmap_new(&image_hash_ops);
 145         if (!images)
 146                 return -ENOMEM;
 147
 148         r = manager_image_cache_discover(m, images, error);
 149         if (r < 0)
 150                 return r;
 151
 152         r = sd_bus_message_new_method_return(message, &reply);
 153         if (r < 0)
 154                 return r;
 155
 156         r = sd_bus_message_open_container(reply, 'a', "(ssbtttso)");
 157         if (r < 0)
 158                 return r;
 159
 160         HASHMAP_FOREACH(image, images, i) {
 161                 _cleanup_(sd_bus_error_free) sd_bus_error error_state = SD_BUS_ERROR_NULL;
 162                 PortableState state = _PORTABLE_STATE_INVALID;
 163                 _cleanup_free_ char *p = NULL;
 164
 165                 r = bus_image_path(image, &p);
 166                 if (r < 0)
 167                         return r;
 168
 169                 r = portable_get_state(
 170                                 sd_bus_message_get_bus(message),
 171                                 image->path,
 172                                 0,
 173                                 &state,
 174                                 &error_state);
 175                 if (r < 0)
 176                         log_debug_errno(r, "Failed to get state of image '%s', ignoring: %s",
 177                                         image->path, bus_error_message(&error_state, r));
 178
 179                 r = sd_bus_message_append(reply, "(ssbtttso)",
 180                                           image->name,
 181                                           image_type_to_string(image->type),
 182                                           image->read_only,
 183                                           image->crtime,
 184                                           image->mtime,
 185                                           image->usage,
 186                                           portable_state_to_string(state),
 187                                           p);
 188                 if (r < 0)
 189                         return r;
 190         }
 191
 192         r = sd_bus_message_close_container(reply);
 193         if (r < 0)
 194                 return r;
 195
 196         return sd_bus_send(NULL, reply, NULL);
 197 }
 198
 199 static int redirect_method_to_image(
 200                 Manager *m,
 201                 sd_bus_message *message,
 202                 sd_bus_error *error,
 203                 int (*method)(Manager *m, sd_bus_message *message, const char *name_or_path, Image *image, sd_bus_error* error)) {
 204
 205         const char *name_or_path;
 206         int r;
 207
 208         assert(m);
 209         assert(message);
 210         assert(method);
 211
 212         r = sd_bus_message_read(message, "s", &name_or_path);
 213         if (r < 0)
 214                 return r;
 215
 216         return method(m, message, name_or_path, NULL, error);
 217 }
 218
 219 static int method_get_image_os_release(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 220         return redirect_method_to_image(userdata, message, error, bus_image_common_get_os_release);
 221 }
 222
 223 static int method_get_image_metadata(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 224         return redirect_method_to_image(userdata, message, error, bus_image_common_get_metadata);
 225 }
 226
 227 static int method_get_image_state(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 228         const char *name_or_path;
 229         PortableState state;
 230         int r;
 231
 232         assert(message);
 233
 234         r = sd_bus_message_read(message, "s", &name_or_path);
 235         if (r < 0)
 236                 return r;
 237
 238         r = portable_get_state(
 239                         sd_bus_message_get_bus(message),
 240                         name_or_path,
 241                         0,
 242                         &state,
 243                         error);
 244         if (r < 0)
 245                 return r;
 246
 247         return sd_bus_reply_method_return(message, "s", portable_state_to_string(state));
 248 }
 249
 250 static int method_attach_image(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 251         return redirect_method_to_image(userdata, message, error, bus_image_common_attach);
 252 }
 253
 254 static int method_detach_image(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 255         PortableChange *changes = NULL;
 256         Manager *m = userdata;
 257         size_t n_changes = 0;
 258         const char *name_or_path;
 259         int r, runtime;
 260
 261         assert(message);
 262         assert(m);
 263
 264         /* Note that we do not redirect detaching to the image object here, because we want to allow that users can
 265          * detach already deleted images too, in case the user already deleted an image before properly detaching
 266          * it. */
 267
 268         r = sd_bus_message_read(message, "sb", &name_or_path, &runtime);
 269         if (r < 0)
 270                 return r;
 271
 272         r = bus_verify_polkit_async(
 273                         message,
 274                         CAP_SYS_ADMIN,
 275                         "org.freedesktop.portable1.attach-images",
 276                         NULL,
 277                         false,
 278                         UID_INVALID,
 279                         &m->polkit_registry,
 280                         error);
 281         if (r < 0)
 282                 return r;
 283         if (r == 0)
 284                 return 1; /* Will call us back */
 285
 286         r = portable_detach(
 287                         sd_bus_message_get_bus(message),
 288                         name_or_path,
 289                         runtime ? PORTABLE_RUNTIME : 0,
 290                         &changes,
 291                         &n_changes,
 292                         error);
 293         if (r < 0)
 294                 goto finish;
 295
 296         r = reply_portable_changes(message, changes, n_changes);
 297
 298 finish:
 299         portable_changes_free(changes, n_changes);
 300         return r;
 301 }
 302
 303 static int method_remove_image(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 304         return redirect_method_to_image(userdata, message, error, bus_image_common_remove);
 305 }
 306
 307 static int method_mark_image_read_only(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 308         return redirect_method_to_image(userdata, message, error, bus_image_common_mark_read_only);
 309 }
 310
 311 static int method_set_image_limit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 312         return redirect_method_to_image(userdata, message, error, bus_image_common_set_limit);
 313 }
 314
 315 static int method_set_pool_limit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 316         Manager *m = userdata;
 317         uint64_t limit;
 318         int r;
 319
 320         assert(message);
 321
 322         r = sd_bus_message_read(message, "t", &limit);
 323         if (r < 0)
 324                 return r;
 325         if (!FILE_SIZE_VALID_OR_INFINITY(limit))
 326                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "New limit out of range");
 327
 328         r = bus_verify_polkit_async(
 329                         message,
 330                         CAP_SYS_ADMIN,
 331                         "org.freedesktop.portable1.manage-images",
 332                         NULL,
 333                         false,
 334                         UID_INVALID,
 335                         &m->polkit_registry,
 336                         error);
 337         if (r < 0)
 338                 return r;
 339         if (r == 0)
 340                 return 1; /* Will call us back */
 341
 342         (void) btrfs_qgroup_set_limit("/var/lib/portables", 0, limit);
 343
 344         r = btrfs_subvol_set_subtree_quota_limit("/var/lib/portables", 0, limit);
 345         if (r == -ENOTTY)
 346                 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Quota is only supported on btrfs.");
 347         if (r < 0)
 348                 return sd_bus_error_set_errnof(error, r, "Failed to adjust quota limit: %m");
 349
 350         return sd_bus_reply_method_return(message, NULL);
 351 }
 352
 353 const sd_bus_vtable manager_vtable[] = {
 354         SD_BUS_VTABLE_START(0),
 355         SD_BUS_PROPERTY("PoolPath", "s", property_get_pool_path, 0, 0),
 356         SD_BUS_PROPERTY("PoolUsage", "t", property_get_pool_usage, 0, 0),
 357         SD_BUS_PROPERTY("PoolLimit", "t", property_get_pool_limit, 0, 0),
 358         SD_BUS_PROPERTY("Profiles", "as", property_get_profiles, 0, 0),
 359         SD_BUS_METHOD("GetImage", "s", "o", method_get_image, SD_BUS_VTABLE_UNPRIVILEGED),
 360         SD_BUS_METHOD("ListImages", NULL, "a(ssbtttso)", method_list_images, SD_BUS_VTABLE_UNPRIVILEGED),
 361         SD_BUS_METHOD("GetImageOSRelease", "s", "a{ss}", method_get_image_os_release, SD_BUS_VTABLE_UNPRIVILEGED),
 362         SD_BUS_METHOD("GetImageMetadata", "sas", "saya{say}", method_get_image_metadata, SD_BUS_VTABLE_UNPRIVILEGED),
 363         SD_BUS_METHOD("GetImageState", "s", "s", method_get_image_state, SD_BUS_VTABLE_UNPRIVILEGED),
 364         SD_BUS_METHOD("AttachImage", "sassbs", "a(sss)", method_attach_image, SD_BUS_VTABLE_UNPRIVILEGED),
 365         SD_BUS_METHOD("DetachImage", "sb", "a(sss)", method_detach_image, SD_BUS_VTABLE_UNPRIVILEGED),
 366         SD_BUS_METHOD("RemoveImage", "s", NULL, method_remove_image, SD_BUS_VTABLE_UNPRIVILEGED),
 367         SD_BUS_METHOD("MarkImageReadOnly", "sb", NULL, method_mark_image_read_only, SD_BUS_VTABLE_UNPRIVILEGED),
 368         SD_BUS_METHOD("SetImageLimit", "st", NULL, method_set_image_limit, SD_BUS_VTABLE_UNPRIVILEGED),
 369         SD_BUS_METHOD("SetPoolLimit", "t", NULL, method_set_pool_limit, SD_BUS_VTABLE_UNPRIVILEGED),
 370         SD_BUS_VTABLE_END
 371 };
 372
 373 int reply_portable_changes(sd_bus_message *m, const PortableChange *changes, size_t n_changes) {
 374         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 375         size_t i;
 376         int r;
 377
 378         assert(m);
 379         assert(changes || n_changes == 0);
 380
 381         r = sd_bus_message_new_method_return(m, &reply);
 382         if (r < 0)
 383                 return r;
 384
 385         r = sd_bus_message_open_container(reply, 'a', "(sss)");
 386         if (r < 0)
 387                 return r;
 388
 389         for (i = 0; i < n_changes; i++) {
 390                 r = sd_bus_message_append(reply, "(sss)",
 391                                           portable_change_type_to_string(changes[i].type),
 392                                           changes[i].path,
 393                                           changes[i].source);
 394                 if (r < 0)
 395                         return r;
 396         }
 397
 398         r = sd_bus_message_close_container(reply);
 399         if (r < 0)
 400                 return r;
 401
 402         return sd_bus_send(NULL, reply, NULL);
 403 }