src/machine/image-dbus.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2014 Lennart Poettering
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include "alloc-util.h"
  21 #include "bus-label.h"
  22 #include "bus-util.h"
  23 #include "fd-util.h"
  24 #include "image-dbus.h"
  25 #include "io-util.h"
  26 #include "machine-image.h"
  27 #include "process-util.h"
  28 #include "strv.h"
  29 #include "user-util.h"
  30
  31 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_type, image_type, ImageType);
  32
  33 int bus_image_method_remove(
  34                 sd_bus_message *message,
  35                 void *userdata,
  36                 sd_bus_error *error) {
  37
  38         _cleanup_close_pair_ int errno_pipe_fd[2] = { -1, -1 };
  39         Image *image = userdata;
  40         Manager *m = image->userdata;
  41         pid_t child;
  42         int r;
  43
  44         assert(message);
  45         assert(image);
  46
  47         if (m->n_operations >= OPERATIONS_MAX)
  48                 return sd_bus_error_setf(error, SD_BUS_ERROR_LIMITS_EXCEEDED, "Too many ongoing operations.");
  49
  50         r = bus_verify_polkit_async(
  51                         message,
  52                         CAP_SYS_ADMIN,
  53                         "org.freedesktop.machine1.manage-images",
  54                         NULL,
  55                         false,
  56                         UID_INVALID,
  57                         &m->polkit_registry,
  58                         error);
  59         if (r < 0)
  60                 return r;
  61         if (r == 0)
  62                 return 1; /* Will call us back */
  63
  64         if (pipe2(errno_pipe_fd, O_CLOEXEC|O_NONBLOCK) < 0)
  65                 return sd_bus_error_set_errnof(error, errno, "Failed to create pipe: %m");
  66
  67         child = fork();
  68         if (child < 0)
  69                 return sd_bus_error_set_errnof(error, errno, "Failed to fork(): %m");
  70         if (child == 0) {
  71                 errno_pipe_fd[0] = safe_close(errno_pipe_fd[0]);
  72
  73                 r = image_remove(image);
  74                 if (r < 0) {
  75                         (void) write(errno_pipe_fd[1], &r, sizeof(r));
  76                         _exit(EXIT_FAILURE);
  77                 }
  78
  79                 _exit(EXIT_SUCCESS);
  80         }
  81
  82         errno_pipe_fd[1] = safe_close(errno_pipe_fd[1]);
  83
  84         r = operation_new(m, NULL, child, message, errno_pipe_fd[0], NULL);
  85         if (r < 0) {
  86                 (void) sigkill_wait(child);
  87                 return r;
  88         }
  89
  90         errno_pipe_fd[0] = -1;
  91
  92         return 1;
  93 }
  94
  95 int bus_image_method_rename(
  96                 sd_bus_message *message,
  97                 void *userdata,
  98                 sd_bus_error *error) {
  99
 100         Image *image = userdata;
 101         Manager *m = image->userdata;
 102         const char *new_name;
 103         int r;
 104
 105         assert(message);
 106         assert(image);
 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         r = bus_verify_polkit_async(
 116                         message,
 117                         CAP_SYS_ADMIN,
 118                         "org.freedesktop.machine1.manage-images",
 119                         NULL,
 120                         false,
 121                         UID_INVALID,
 122                         &m->polkit_registry,
 123                         error);
 124         if (r < 0)
 125                 return r;
 126         if (r == 0)
 127                 return 1; /* Will call us back */
 128
 129         r = image_rename(image, new_name);
 130         if (r < 0)
 131                 return r;
 132
 133         return sd_bus_reply_method_return(message, NULL);
 134 }
 135
 136 int bus_image_method_clone(
 137                 sd_bus_message *message,
 138                 void *userdata,
 139                 sd_bus_error *error) {
 140
 141         _cleanup_close_pair_ int errno_pipe_fd[2] = { -1, -1 };
 142         Image *image = userdata;
 143         Manager *m = image->userdata;
 144         const char *new_name;
 145         int r, read_only;
 146         pid_t child;
 147
 148         assert(message);
 149         assert(image);
 150         assert(m);
 151
 152         if (m->n_operations >= OPERATIONS_MAX)
 153                 return sd_bus_error_setf(error, SD_BUS_ERROR_LIMITS_EXCEEDED, "Too many ongoing operations.");
 154
 155         r = sd_bus_message_read(message, "sb", &new_name, &read_only);
 156         if (r < 0)
 157                 return r;
 158
 159         if (!image_name_is_valid(new_name))
 160                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Image name '%s' is invalid.", new_name);
 161
 162         r = bus_verify_polkit_async(
 163                         message,
 164                         CAP_SYS_ADMIN,
 165                         "org.freedesktop.machine1.manage-images",
 166                         NULL,
 167                         false,
 168                         UID_INVALID,
 169                         &m->polkit_registry,
 170                         error);
 171         if (r < 0)
 172                 return r;
 173         if (r == 0)
 174                 return 1; /* Will call us back */
 175
 176         if (pipe2(errno_pipe_fd, O_CLOEXEC|O_NONBLOCK) < 0)
 177                 return sd_bus_error_set_errnof(error, errno, "Failed to create pipe: %m");
 178
 179         child = fork();
 180         if (child < 0)
 181                 return sd_bus_error_set_errnof(error, errno, "Failed to fork(): %m");
 182         if (child == 0) {
 183                 errno_pipe_fd[0] = safe_close(errno_pipe_fd[0]);
 184
 185                 r = image_clone(image, new_name, read_only);
 186                 if (r < 0) {
 187                         (void) write(errno_pipe_fd[1], &r, sizeof(r));
 188                         _exit(EXIT_FAILURE);
 189                 }
 190
 191                 _exit(EXIT_SUCCESS);
 192         }
 193
 194         errno_pipe_fd[1] = safe_close(errno_pipe_fd[1]);
 195
 196         r = operation_new(m, NULL, child, message, errno_pipe_fd[0], NULL);
 197         if (r < 0) {
 198                 (void) sigkill_wait(child);
 199                 return r;
 200         }
 201
 202         errno_pipe_fd[0] = -1;
 203
 204         return 1;
 205 }
 206
 207 int bus_image_method_mark_read_only(
 208                 sd_bus_message *message,
 209                 void *userdata,
 210                 sd_bus_error *error) {
 211
 212         Image *image = userdata;
 213         Manager *m = image->userdata;
 214         int r, read_only;
 215
 216         assert(message);
 217
 218         r = sd_bus_message_read(message, "b", &read_only);
 219         if (r < 0)
 220                 return r;
 221
 222         r = bus_verify_polkit_async(
 223                         message,
 224                         CAP_SYS_ADMIN,
 225                         "org.freedesktop.machine1.manage-images",
 226                         NULL,
 227                         false,
 228                         UID_INVALID,
 229                         &m->polkit_registry,
 230                         error);
 231         if (r < 0)
 232                 return r;
 233         if (r == 0)
 234                 return 1; /* Will call us back */
 235
 236         r = image_read_only(image, read_only);
 237         if (r < 0)
 238                 return r;
 239
 240         return sd_bus_reply_method_return(message, NULL);
 241 }
 242
 243 int bus_image_method_set_limit(
 244                 sd_bus_message *message,
 245                 void *userdata,
 246                 sd_bus_error *error) {
 247
 248         Image *image = userdata;
 249         Manager *m = image->userdata;
 250         uint64_t limit;
 251         int r;
 252
 253         assert(message);
 254
 255         r = sd_bus_message_read(message, "t", &limit);
 256         if (r < 0)
 257                 return r;
 258         if (!FILE_SIZE_VALID_OR_INFINITY(limit))
 259                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "New limit out of range");
 260
 261         r = bus_verify_polkit_async(
 262                         message,
 263                         CAP_SYS_ADMIN,
 264                         "org.freedesktop.machine1.manage-images",
 265                         NULL,
 266                         false,
 267                         UID_INVALID,
 268                         &m->polkit_registry,
 269                         error);
 270         if (r < 0)
 271                 return r;
 272         if (r == 0)
 273                 return 1; /* Will call us back */
 274
 275         r = image_set_limit(image, limit);
 276         if (r < 0)
 277                 return r;
 278
 279         return sd_bus_reply_method_return(message, NULL);
 280 }
 281
 282 const sd_bus_vtable image_vtable[] = {
 283         SD_BUS_VTABLE_START(0),
 284         SD_BUS_PROPERTY("Name", "s", NULL, offsetof(Image, name), 0),
 285         SD_BUS_PROPERTY("Path", "s", NULL, offsetof(Image, path), 0),
 286         SD_BUS_PROPERTY("Type", "s", property_get_type,  offsetof(Image, type), 0),
 287         SD_BUS_PROPERTY("ReadOnly", "b", bus_property_get_bool, offsetof(Image, read_only), 0),
 288         SD_BUS_PROPERTY("CreationTimestamp", "t", NULL, offsetof(Image, crtime), 0),
 289         SD_BUS_PROPERTY("ModificationTimestamp", "t", NULL, offsetof(Image, mtime), 0),
 290         SD_BUS_PROPERTY("Usage", "t", NULL, offsetof(Image, usage), 0),
 291         SD_BUS_PROPERTY("Limit", "t", NULL, offsetof(Image, limit), 0),
 292         SD_BUS_PROPERTY("UsageExclusive", "t", NULL, offsetof(Image, usage_exclusive), 0),
 293         SD_BUS_PROPERTY("LimitExclusive", "t", NULL, offsetof(Image, limit_exclusive), 0),
 294         SD_BUS_METHOD("Remove", NULL, NULL, bus_image_method_remove, SD_BUS_VTABLE_UNPRIVILEGED),
 295         SD_BUS_METHOD("Rename", "s", NULL, bus_image_method_rename, SD_BUS_VTABLE_UNPRIVILEGED),
 296         SD_BUS_METHOD("Clone", "sb", NULL, bus_image_method_clone, SD_BUS_VTABLE_UNPRIVILEGED),
 297         SD_BUS_METHOD("MarkReadOnly", "b", NULL, bus_image_method_mark_read_only, SD_BUS_VTABLE_UNPRIVILEGED),
 298         SD_BUS_METHOD("SetLimit", "t", NULL, bus_image_method_set_limit, SD_BUS_VTABLE_UNPRIVILEGED),
 299         SD_BUS_VTABLE_END
 300 };
 301
 302 static int image_flush_cache(sd_event_source *s, void *userdata) {
 303         Manager *m = userdata;
 304         Image *i;
 305
 306         assert(s);
 307         assert(m);
 308
 309         while ((i = hashmap_steal_first(m->image_cache)))
 310                 image_unref(i);
 311
 312         return 0;
 313 }
 314
 315 int image_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
 316         _cleanup_free_ char *e = NULL;
 317         Manager *m = userdata;
 318         Image *image = NULL;
 319         const char *p;
 320         int r;
 321
 322         assert(bus);
 323         assert(path);
 324         assert(interface);
 325         assert(found);
 326
 327         p = startswith(path, "/org/freedesktop/machine1/image/");
 328         if (!p)
 329                 return 0;
 330
 331         e = bus_label_unescape(p);
 332         if (!e)
 333                 return -ENOMEM;
 334
 335         image = hashmap_get(m->image_cache, e);
 336         if (image) {
 337                 *found = image;
 338                 return 1;
 339         }
 340
 341         r = hashmap_ensure_allocated(&m->image_cache, &string_hash_ops);
 342         if (r < 0)
 343                 return r;
 344
 345         if (!m->image_cache_defer_event) {
 346                 r = sd_event_add_defer(m->event, &m->image_cache_defer_event, image_flush_cache, m);
 347                 if (r < 0)
 348                         return r;
 349
 350                 r = sd_event_source_set_priority(m->image_cache_defer_event, SD_EVENT_PRIORITY_IDLE);
 351                 if (r < 0)
 352                         return r;
 353         }
 354
 355         r = sd_event_source_set_enabled(m->image_cache_defer_event, SD_EVENT_ONESHOT);
 356         if (r < 0)
 357                 return r;
 358
 359         r = image_find(e, &image);
 360         if (r <= 0)
 361                 return r;
 362
 363         image->userdata = m;
 364
 365         r = hashmap_put(m->image_cache, image->name, image);
 366         if (r < 0) {
 367                 image_unref(image);
 368                 return r;
 369         }
 370
 371         *found = image;
 372         return 1;
 373 }
 374
 375 char *image_bus_path(const char *name) {
 376         _cleanup_free_ char *e = NULL;
 377
 378         assert(name);
 379
 380         e = bus_label_escape(name);
 381         if (!e)
 382                 return NULL;
 383
 384         return strappend("/org/freedesktop/machine1/image/", e);
 385 }
 386
 387 int image_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
 388         _cleanup_(image_hashmap_freep) Hashmap *images = NULL;
 389         _cleanup_strv_free_ char **l = NULL;
 390         Image *image;
 391         Iterator i;
 392         int r;
 393
 394         assert(bus);
 395         assert(path);
 396         assert(nodes);
 397
 398         images = hashmap_new(&string_hash_ops);
 399         if (!images)
 400                 return -ENOMEM;
 401
 402         r = image_discover(images);
 403         if (r < 0)
 404                 return r;
 405
 406         HASHMAP_FOREACH(image, images, i) {
 407                 char *p;
 408
 409                 p = image_bus_path(image->name);
 410                 if (!p)
 411                         return -ENOMEM;
 412
 413                 r = strv_consume(&l, p);
 414                 if (r < 0)
 415                         return r;
 416         }
 417
 418         *nodes = l;
 419         l = NULL;
 420
 421         return 1;
 422 }