Line data    Source code

       1             : /* SPDX-License-Identifier: LGPL-2.1+ */
       2             : 
       3             : #include "bus-util.h"
       4             : #include "dbus-util.h"
       5             : #include "parse-util.h"
       6             : #include "path-util.h"
       7             : #include "unit-printf.h"
       8             : #include "user-util.h"
       9             : #include "unit.h"
      10             : 
      11           0 : int bus_property_get_triggered_unit(
      12             :                 sd_bus *bus,
      13             :                 const char *path,
      14             :                 const char *interface,
      15             :                 const char *property,
      16             :                 sd_bus_message *reply,
      17             :                 void *userdata,
      18             :                 sd_bus_error *error) {
      19             : 
      20           0 :         Unit *u = userdata, *trigger;
      21             : 
      22           0 :         assert(bus);
      23           0 :         assert(reply);
      24           0 :         assert(u);
      25             : 
      26           0 :         trigger = UNIT_TRIGGER(u);
      27             : 
      28           0 :         return sd_bus_message_append(reply, "s", trigger ? trigger->id : NULL);
      29             : }
      30             : 
      31           0 : BUS_DEFINE_SET_TRANSIENT(mode_t, "u", uint32_t, mode_t, "%040o");
      32           0 : BUS_DEFINE_SET_TRANSIENT(unsigned, "u", uint32_t, unsigned, "%" PRIu32);
      33           0 : BUS_DEFINE_SET_TRANSIENT_STRING_WITH_CHECK(user, valid_user_group_name_or_id);
      34           0 : BUS_DEFINE_SET_TRANSIENT_STRING_WITH_CHECK(path, path_is_absolute);
      35             : 
      36           0 : int bus_set_transient_string(
      37             :                 Unit *u,
      38             :                 const char *name,
      39             :                 char **p,
      40             :                 sd_bus_message *message,
      41             :                 UnitWriteFlags flags,
      42             :                 sd_bus_error *error) {
      43             : 
      44             :         const char *v;
      45             :         int r;
      46             : 
      47           0 :         assert(p);
      48             : 
      49           0 :         r = sd_bus_message_read(message, "s", &v);
      50           0 :         if (r < 0)
      51           0 :                 return r;
      52             : 
      53           0 :         if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
      54           0 :                 r = free_and_strdup(p, empty_to_null(v));
      55           0 :                 if (r < 0)
      56           0 :                         return r;
      57             : 
      58           0 :                 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name,
      59             :                                     "%s=%s", name, strempty(v));
      60             :         }
      61             : 
      62           0 :         return 1;
      63             : }
      64             : 
      65           0 : int bus_set_transient_bool(
      66             :                 Unit *u,
      67             :                 const char *name,
      68             :                 bool *p,
      69             :                 sd_bus_message *message,
      70             :                 UnitWriteFlags flags,
      71             :                 sd_bus_error *error) {
      72             : 
      73             :         int v, r;
      74             : 
      75           0 :         assert(p);
      76             : 
      77           0 :         r = sd_bus_message_read(message, "b", &v);
      78           0 :         if (r < 0)
      79           0 :                 return r;
      80             : 
      81           0 :         if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
      82           0 :                 *p = v;
      83           0 :                 unit_write_settingf(u, flags, name, "%s=%s", name, yes_no(v));
      84             :         }
      85             : 
      86           0 :         return 1;
      87             : }
      88             : 
      89           0 : int bus_set_transient_usec_internal(
      90             :                 Unit *u,
      91             :                 const char *name,
      92             :                 usec_t *p,
      93             :                 bool fix_0,
      94             :                 sd_bus_message *message,
      95             :                 UnitWriteFlags flags,
      96             :                 sd_bus_error *error) {
      97             : 
      98             :         uint64_t v;
      99             :         int r;
     100             : 
     101           0 :         assert(p);
     102             : 
     103           0 :         r = sd_bus_message_read(message, "t", &v);
     104           0 :         if (r < 0)
     105           0 :                 return r;
     106             : 
     107           0 :         if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
     108             :                 char *n, ts[FORMAT_TIMESPAN_MAX];
     109             : 
     110           0 :                 if (fix_0)
     111           0 :                         *p = v != 0 ? v: USEC_INFINITY;
     112             :                 else
     113           0 :                         *p = v;
     114             : 
     115           0 :                 n = strndupa(name, strlen(name) - 4);
     116           0 :                 unit_write_settingf(u, flags, name, "%sSec=%s", n,
     117             :                                     format_timespan(ts, sizeof(ts), v, USEC_PER_MSEC));
     118             :         }
     119             : 
     120           0 :         return 1;
     121             : }