Line data    Source code

       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           0 : static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_result, path_result, PathResult);
      14             : 
      15           0 : 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           0 :         Path *p = userdata;
      25             :         PathSpec *k;
      26             :         int r;
      27             : 
      28           0 :         assert(bus);
      29           0 :         assert(reply);
      30           0 :         assert(p);
      31             : 
      32           0 :         r = sd_bus_message_open_container(reply, 'a', "(ss)");
      33           0 :         if (r < 0)
      34           0 :                 return r;
      35             : 
      36           0 :         LIST_FOREACH(spec, k, p->specs) {
      37           0 :                 r = sd_bus_message_append(reply, "(ss)", path_type_to_string(k->type), k->path);
      38           0 :                 if (r < 0)
      39           0 :                         return r;
      40             :         }
      41             : 
      42           0 :         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           0 : 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           0 :         Unit *u = UNIT(p);
      63             :         int r;
      64             : 
      65           0 :         assert(p);
      66           0 :         assert(name);
      67           0 :         assert(message);
      68             : 
      69           0 :         flags |= UNIT_PRIVATE;
      70             : 
      71           0 :         if (streq(name, "MakeDirectory"))
      72           0 :                 return bus_set_transient_bool(u, name, &p->make_directory, message, flags, error);
      73             : 
      74           0 :         if (streq(name, "DirectoryMode"))
      75           0 :                 return bus_set_transient_mode_t(u, name, &p->directory_mode, message, flags, error);
      76             : 
      77           0 :         if (streq(name, "Paths")) {
      78             :                 const char *type_name, *path;
      79           0 :                 bool empty = true;
      80             : 
      81           0 :                 r = sd_bus_message_enter_container(message, 'a', "(ss)");
      82           0 :                 if (r < 0)
      83           0 :                         return r;
      84             : 
      85           0 :                 while ((r = sd_bus_message_read(message, "(ss)", &type_name, &path)) > 0) {
      86             :                         PathType t;
      87             : 
      88           0 :                         t = path_type_from_string(type_name);
      89           0 :                         if (t < 0)
      90           0 :                                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown path type: %s", type_name);
      91             : 
      92           0 :                         if (isempty(path))
      93           0 :                                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Path in %s is empty", type_name);
      94             : 
      95           0 :                         if (!path_is_absolute(path))
      96           0 :                                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Path in %s is not absolute: %s", type_name, path);
      97             : 
      98           0 :                         if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
      99           0 :                                 _cleanup_free_ char *k;
     100             :                                 PathSpec *s;
     101             : 
     102           0 :                                 k = strdup(path);
     103           0 :                                 if (!k)
     104           0 :                                         return -ENOMEM;
     105             : 
     106           0 :                                 path_simplify(k, false);
     107             : 
     108           0 :                                 s = new0(PathSpec, 1);
     109           0 :                                 if (!s)
     110           0 :                                         return -ENOMEM;
     111             : 
     112           0 :                                 s->unit = u;
     113           0 :                                 s->path = TAKE_PTR(k);
     114           0 :                                 s->type = t;
     115           0 :                                 s->inotify_fd = -1;
     116             : 
     117           0 :                                 LIST_PREPEND(spec, p->specs, s);
     118             : 
     119           0 :                                 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "%s=%s", type_name, path);
     120             :                         }
     121             : 
     122           0 :                         empty = false;
     123             :                 }
     124           0 :                 if (r < 0)
     125           0 :                         return r;
     126             : 
     127           0 :                 r = sd_bus_message_exit_container(message);
     128           0 :                 if (r < 0)
     129           0 :                         return r;
     130             : 
     131           0 :                 if (!UNIT_WRITE_FLAGS_NOOP(flags) && empty) {
     132           0 :                         path_free_specs(p);
     133           0 :                         unit_write_settingf(u, flags, name, "PathExists=");
     134             :                 }
     135             : 
     136           0 :                 return 1;
     137             :         }
     138             : 
     139           0 :         return 0;
     140             : }
     141             : 
     142           0 : 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           0 :         Path *p = PATH(u);
     150             : 
     151           0 :         assert(p);
     152           0 :         assert(name);
     153           0 :         assert(message);
     154             : 
     155           0 :         if (u->transient && u->load_state == UNIT_STUB)
     156           0 :                 return bus_path_set_transient_property(p, name, message, mode, error);
     157             : 
     158           0 :         return 0;
     159             : }