src/core/dbus-service.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include "strv.h"
  23 #include "path-util.h"
  24 #include "unit.h"
  25 #include "service.h"
  26 #include "dbus-unit.h"
  27 #include "dbus-execute.h"
  28 #include "dbus-kill.h"
  29 #include "dbus-cgroup.h"
  30 #include "dbus-service.h"
  31 #include "bus-util.h"
  32
  33 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_type, service_type, ServiceType);
  34 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_result, service_result, ServiceResult);
  35 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_restart, service_restart, ServiceRestart);
  36 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_notify_access, notify_access, NotifyAccess);
  37 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_start_limit_action, start_limit_action, StartLimitAction);
  38
  39 const sd_bus_vtable bus_service_vtable[] = {
  40         SD_BUS_VTABLE_START(0),
  41         SD_BUS_PROPERTY("Type", "s", property_get_type, offsetof(Service, type), SD_BUS_VTABLE_PROPERTY_CONST),
  42         SD_BUS_PROPERTY("Restart", "s", property_get_restart, offsetof(Service, restart), SD_BUS_VTABLE_PROPERTY_CONST),
  43         SD_BUS_PROPERTY("PIDFile", "s", NULL, offsetof(Service, pid_file), SD_BUS_VTABLE_PROPERTY_CONST),
  44         SD_BUS_PROPERTY("NotifyAccess", "s", property_get_notify_access, offsetof(Service, notify_access), SD_BUS_VTABLE_PROPERTY_CONST),
  45         SD_BUS_PROPERTY("RestartUSec", "t", bus_property_get_usec, offsetof(Service, restart_usec), SD_BUS_VTABLE_PROPERTY_CONST),
  46         SD_BUS_PROPERTY("TimeoutStartUSec", "t", bus_property_get_usec, offsetof(Service, timeout_start_usec), SD_BUS_VTABLE_PROPERTY_CONST),
  47         SD_BUS_PROPERTY("TimeoutStopUSec", "t", bus_property_get_usec, offsetof(Service, timeout_stop_usec), SD_BUS_VTABLE_PROPERTY_CONST),
  48         SD_BUS_PROPERTY("WatchdogUSec", "t", bus_property_get_usec, offsetof(Service, watchdog_usec), SD_BUS_VTABLE_PROPERTY_CONST),
  49         BUS_PROPERTY_DUAL_TIMESTAMP("WatchdogTimestamp", offsetof(Service, watchdog_timestamp), 0),
  50         SD_BUS_PROPERTY("StartLimitInterval", "t", bus_property_get_usec, offsetof(Service, start_limit.interval), SD_BUS_VTABLE_PROPERTY_CONST),
  51         SD_BUS_PROPERTY("StartLimitBurst", "u", bus_property_get_unsigned, offsetof(Service, start_limit.burst), SD_BUS_VTABLE_PROPERTY_CONST),
  52         SD_BUS_PROPERTY("StartLimitAction", "s", property_get_start_limit_action, offsetof(Service, start_limit_action), SD_BUS_VTABLE_PROPERTY_CONST),
  53         SD_BUS_PROPERTY("PermissionsStartOnly", "b", bus_property_get_bool, offsetof(Service, permissions_start_only), SD_BUS_VTABLE_PROPERTY_CONST),
  54         SD_BUS_PROPERTY("RootDirectoryStartOnly", "b", bus_property_get_bool, offsetof(Service, root_directory_start_only), SD_BUS_VTABLE_PROPERTY_CONST),
  55         SD_BUS_PROPERTY("RemainAfterExit", "b", bus_property_get_bool, offsetof(Service, remain_after_exit), SD_BUS_VTABLE_PROPERTY_CONST),
  56         SD_BUS_PROPERTY("GuessMainPID", "b", bus_property_get_bool, offsetof(Service, guess_main_pid), SD_BUS_VTABLE_PROPERTY_CONST),
  57         SD_BUS_PROPERTY("MainPID", "u", bus_property_get_pid, offsetof(Service, main_pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  58         SD_BUS_PROPERTY("ControlPID", "u", bus_property_get_pid, offsetof(Service, control_pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  59         SD_BUS_PROPERTY("BusName", "s", NULL, offsetof(Service, bus_name), SD_BUS_VTABLE_PROPERTY_CONST),
  60         SD_BUS_PROPERTY("StatusText", "s", NULL, offsetof(Service, status_text), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  61         SD_BUS_PROPERTY("Result", "s", property_get_result, offsetof(Service, result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  62         BUS_EXEC_STATUS_VTABLE("ExecMain", offsetof(Service, main_exec_status), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  63         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPre", offsetof(Service, exec_command[SERVICE_EXEC_START_PRE]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
  64         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStart", offsetof(Service, exec_command[SERVICE_EXEC_START]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
  65         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPost", offsetof(Service, exec_command[SERVICE_EXEC_START_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
  66         BUS_EXEC_COMMAND_LIST_VTABLE("ExecReload", offsetof(Service, exec_command[SERVICE_EXEC_RELOAD]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
  67         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStop", offsetof(Service, exec_command[SERVICE_EXEC_STOP]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
  68         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStopPost", offsetof(Service, exec_command[SERVICE_EXEC_STOP_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
  69         SD_BUS_VTABLE_END
  70 };
  71
  72 static int bus_service_set_transient_property(
  73                 Service *s,
  74                 const char *name,
  75                 sd_bus_message *message,
  76                 UnitSetPropertiesMode mode,
  77                 sd_bus_error *error) {
  78
  79         int r;
  80
  81         assert(s);
  82         assert(name);
  83         assert(message);
  84
  85         if (streq(name, "RemainAfterExit")) {
  86                 int b;
  87
  88                 r = sd_bus_message_read(message, "b", &b);
  89                 if (r < 0)
  90                         return r;
  91
  92                 if (mode != UNIT_CHECK) {
  93                         s->remain_after_exit = b;
  94                         unit_write_drop_in_private_format(UNIT(s), mode, name, "RemainAfterExit=%s\n", yes_no(b));
  95                 }
  96
  97                 return 1;
  98
  99         } else if (streq(name, "Type")) {
 100                 const char *t;
 101                 ServiceType k;
 102
 103                 r = sd_bus_message_read(message, "s", &t);
 104                 if (r < 0)
 105                         return r;
 106
 107                 k = service_type_from_string(t);
 108                 if (k < 0)
 109                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid service type %s", t);
 110
 111                 if (mode != UNIT_CHECK) {
 112                         s->type = k;
 113                         unit_write_drop_in_private_format(UNIT(s), mode, name, "Type=%s\n", service_type_to_string(s->type));
 114                 }
 115
 116                 return 1;
 117
 118         } else if (streq(name, "ExecStart")) {
 119                 unsigned n = 0;
 120
 121                 r = sd_bus_message_enter_container(message, 'a', "(sasb)");
 122                 if (r < 0)
 123                         return r;
 124
 125                 while ((r = sd_bus_message_enter_container(message, 'r', "sasb")) > 0) {
 126                         _cleanup_strv_free_ char **argv = NULL;
 127                         const char *path;
 128                         int b;
 129
 130                         r = sd_bus_message_read(message, "s", &path);
 131                         if (r < 0)
 132                                 return r;
 133
 134                         if (!path_is_absolute(path))
 135                                 return sd_bus_error_set_errnof(error, EINVAL, "Path %s is not absolute.", path);
 136
 137                         r = sd_bus_message_read_strv(message, &argv);
 138                         if (r < 0)
 139                                 return r;
 140
 141                         r = sd_bus_message_read(message, "b", &b);
 142                         if (r < 0)
 143                                 return r;
 144
 145                         r = sd_bus_message_exit_container(message);
 146                         if (r < 0)
 147                                 return r;
 148
 149                         if (mode != UNIT_CHECK) {
 150                                 ExecCommand *c;
 151
 152                                 c = new0(ExecCommand, 1);
 153                                 if (!c)
 154                                         return -ENOMEM;
 155
 156                                 c->path = strdup(path);
 157                                 if (!c->path) {
 158                                         free(c);
 159                                         return -ENOMEM;
 160                                 }
 161
 162                                 c->argv = argv;
 163                                 argv = NULL;
 164
 165                                 c->ignore = b;
 166
 167                                 path_kill_slashes(c->path);
 168                                 exec_command_append_list(&s->exec_command[SERVICE_EXEC_START], c);
 169                         }
 170
 171                         n++;
 172                 }
 173
 174                 if (r < 0)
 175                         return r;
 176
 177                 r = sd_bus_message_exit_container(message);
 178                 if (r < 0)
 179                         return r;
 180
 181                 if (mode != UNIT_CHECK) {
 182                         _cleanup_free_ char *buf = NULL;
 183                         _cleanup_fclose_ FILE *f = NULL;
 184                         ExecCommand *c;
 185                         size_t size = 0;
 186
 187                         if (n == 0) {
 188                                 exec_command_free_list(s->exec_command[SERVICE_EXEC_START]);
 189                                 s->exec_command[SERVICE_EXEC_START] = NULL;
 190                         }
 191
 192                         f = open_memstream(&buf, &size);
 193                         if (!f)
 194                                 return -ENOMEM;
 195
 196                         fputs("ExecStart=\n", f);
 197
 198                         LIST_FOREACH(command, c, s->exec_command[SERVICE_EXEC_START]) {
 199                                 _cleanup_free_ char *a;
 200
 201                                 a = strv_join_quoted(c->argv);
 202                                 if (!a)
 203                                         return -ENOMEM;
 204
 205                                 fprintf(f, "ExecStart=%s@%s %s\n",
 206                                         c->ignore ? "-" : "",
 207                                         c->path,
 208                                         a);
 209                         }
 210
 211                         fflush(f);
 212                         unit_write_drop_in_private(UNIT(s), mode, name, buf);
 213                 }
 214
 215                 return 1;
 216         }
 217
 218         return 0;
 219 }
 220
 221 int bus_service_set_property(
 222                 Unit *u,
 223                 const char *name,
 224                 sd_bus_message *message,
 225                 UnitSetPropertiesMode mode,
 226                 sd_bus_error *error) {
 227
 228         Service *s = SERVICE(u);
 229         int r;
 230
 231         assert(s);
 232         assert(name);
 233         assert(message);
 234
 235         r = bus_cgroup_set_property(u, &s->cgroup_context, name, message, mode, error);
 236         if (r != 0)
 237                 return r;
 238
 239         if (u->transient && u->load_state == UNIT_STUB) {
 240                 /* This is a transient unit, let's load a little more */
 241
 242                 r = bus_service_set_transient_property(s, name, message, mode, error);
 243                 if (r != 0)
 244                         return r;
 245
 246                 r = bus_exec_context_set_transient_property(u, &s->exec_context, name, message, mode, error);
 247                 if (r != 0)
 248                         return r;
 249
 250                 r = bus_kill_context_set_transient_property(u, &s->kill_context, name, message, mode, error);
 251                 if (r != 0)
 252                         return r;
 253         }
 254
 255         return 0;
 256 }
 257
 258 int bus_service_commit_properties(Unit *u) {
 259         assert(u);
 260
 261         unit_update_cgroup_members_masks(u);
 262         unit_realize_cgroup(u);
 263
 264         return 0;
 265 }