src/core/dbus-path.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include "alloc-util.h"
   4 #include "bus-util.h"
   5 #include "dbus-path.h"
   6 #include "dbus-util.h"
   7 #include "list.h"
   8 #include "path.h"
   9 #include "path-util.h"
  10 #include "string-util.h"
  11 #include "unit.h"
  12
  13 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_result, path_result, PathResult);
  14
  15 static int property_get_paths(
  16                 sd_bus *bus,
  17                 const char *path,
  18                 const char *interface,
  19                 const char *property,
  20                 sd_bus_message *reply,
  21                 void *userdata,
  22                 sd_bus_error *error) {
  23
  24         Path *p = userdata;
  25         PathSpec *k;
  26         int r;
  27
  28         assert(bus);
  29         assert(reply);
  30         assert(p);
  31
  32         r = sd_bus_message_open_container(reply, 'a', "(ss)");
  33         if (r < 0)
  34                 return r;
  35
  36         LIST_FOREACH(spec, k, p->specs) {
  37                 r = sd_bus_message_append(reply, "(ss)", path_type_to_string(k->type), k->path);
  38                 if (r < 0)
  39                         return r;
  40         }
  41
  42         return sd_bus_message_close_container(reply);
  43 }
  44
  45 const sd_bus_vtable bus_path_vtable[] = {
  46         SD_BUS_VTABLE_START(0),
  47         SD_BUS_PROPERTY("Unit", "s", bus_property_get_triggered_unit, 0, SD_BUS_VTABLE_PROPERTY_CONST),
  48         SD_BUS_PROPERTY("Paths", "a(ss)", property_get_paths, 0, SD_BUS_VTABLE_PROPERTY_CONST),
  49         SD_BUS_PROPERTY("MakeDirectory", "b", bus_property_get_bool, offsetof(Path, make_directory), SD_BUS_VTABLE_PROPERTY_CONST),
  50         SD_BUS_PROPERTY("DirectoryMode", "u", bus_property_get_mode, offsetof(Path, directory_mode), SD_BUS_VTABLE_PROPERTY_CONST),
  51         SD_BUS_PROPERTY("Result", "s", property_get_result, offsetof(Path, result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  52         SD_BUS_VTABLE_END
  53 };
  54
  55 static int bus_path_set_transient_property(
  56                 Path *p,
  57                 const char *name,
  58                 sd_bus_message *message,
  59                 UnitWriteFlags flags,
  60                 sd_bus_error *error) {
  61
  62         Unit *u = UNIT(p);
  63         int r;
  64
  65         assert(p);
  66         assert(name);
  67         assert(message);
  68
  69         flags |= UNIT_PRIVATE;
  70
  71         if (streq(name, "MakeDirectory"))
  72                 return bus_set_transient_bool(u, name, &p->make_directory, message, flags, error);
  73
  74         if (streq(name, "DirectoryMode"))
  75                 return bus_set_transient_mode_t(u, name, &p->directory_mode, message, flags, error);
  76
  77         if (streq(name, "Paths")) {
  78                 const char *type_name, *path;
  79                 bool empty = true;
  80
  81                 r = sd_bus_message_enter_container(message, 'a', "(ss)");
  82                 if (r < 0)
  83                         return r;
  84
  85                 while ((r = sd_bus_message_read(message, "(ss)", &type_name, &path)) > 0) {
  86                         PathType t;
  87
  88                         t = path_type_from_string(type_name);
  89                         if (t < 0)
  90                                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown path type: %s", type_name);
  91
  92                         if (isempty(path))
  93                                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Path in %s is empty", type_name);
  94
  95                         if (!path_is_absolute(path))
  96                                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Path in %s is not absolute: %s", type_name, path);
  97
  98                         if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
  99                                 _cleanup_free_ char *k;
 100                                 PathSpec *s;
 101
 102                                 k = strdup(path);
 103                                 if (!k)
 104                                         return -ENOMEM;
 105
 106                                 path_simplify(k, false);
 107
 108                                 s = new0(PathSpec, 1);
 109                                 if (!s)
 110                                         return -ENOMEM;
 111
 112                                 s->unit = u;
 113                                 s->path = TAKE_PTR(k);
 114                                 s->type = t;
 115                                 s->inotify_fd = -1;
 116
 117                                 LIST_PREPEND(spec, p->specs, s);
 118
 119                                 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "%s=%s", type_name, path);
 120                         }
 121
 122                         empty = false;
 123                 }
 124                 if (r < 0)
 125                         return r;
 126
 127                 r = sd_bus_message_exit_container(message);
 128                 if (r < 0)
 129                         return r;
 130
 131                 if (!UNIT_WRITE_FLAGS_NOOP(flags) && empty) {
 132                         path_free_specs(p);
 133                         unit_write_settingf(u, flags, name, "PathExists=");
 134                 }
 135
 136                 return 1;
 137         }
 138
 139         return 0;
 140 }
 141
 142 int bus_path_set_property(
 143                 Unit *u,
 144                 const char *name,
 145                 sd_bus_message *message,
 146                 UnitWriteFlags mode,
 147                 sd_bus_error *error) {
 148
 149         Path *p = PATH(u);
 150
 151         assert(p);
 152         assert(name);
 153         assert(message);
 154
 155         if (u->transient && u->load_state == UNIT_STUB)
 156                 return bus_path_set_transient_property(p, name, message, mode, error);
 157
 158         return 0;
 159 }