src/core/dbus-socket.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2010 Lennart Poettering
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include "alloc-util.h"
  22 #include "bus-util.h"
  23 #include "dbus-cgroup.h"
  24 #include "dbus-execute.h"
  25 #include "dbus-kill.h"
  26 #include "dbus-socket.h"
  27 #include "dbus-util.h"
  28 #include "fd-util.h"
  29 #include "parse-util.h"
  30 #include "path-util.h"
  31 #include "socket.h"
  32 #include "socket-protocol-list.h"
  33 #include "socket-util.h"
  34 #include "string-util.h"
  35 #include "unit.h"
  36
  37 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_result, socket_result, SocketResult);
  38 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_bind_ipv6_only, socket_address_bind_ipv6_only, SocketAddressBindIPv6Only);
  39
  40 static int property_get_listen(
  41                 sd_bus *bus,
  42                 const char *path,
  43                 const char *interface,
  44                 const char *property,
  45                 sd_bus_message *reply,
  46                 void *userdata,
  47                 sd_bus_error *error) {
  48
  49
  50         Socket *s = SOCKET(userdata);
  51         SocketPort *p;
  52         int r;
  53
  54         assert(bus);
  55         assert(reply);
  56         assert(s);
  57
  58         r = sd_bus_message_open_container(reply, 'a', "(ss)");
  59         if (r < 0)
  60                 return r;
  61
  62         LIST_FOREACH(port, p, s->ports) {
  63                 _cleanup_free_ char *address = NULL;
  64                 const char *a;
  65
  66                 switch (p->type) {
  67                         case SOCKET_SOCKET: {
  68                                 r = socket_address_print(&p->address, &address);
  69                                 if (r)
  70                                         return r;
  71
  72                                 a = address;
  73                                 break;
  74                         }
  75
  76                         case SOCKET_SPECIAL:
  77                         case SOCKET_MQUEUE:
  78                         case SOCKET_FIFO:
  79                         case SOCKET_USB_FUNCTION:
  80                                 a = p->path;
  81                                 break;
  82
  83                         default:
  84                                 assert_not_reached("Unknown socket type");
  85                 }
  86
  87                 r = sd_bus_message_append(reply, "(ss)", socket_port_type_to_string(p), a);
  88                 if (r < 0)
  89                         return r;
  90         }
  91
  92         return sd_bus_message_close_container(reply);
  93 }
  94
  95
  96 static int property_get_fdname(
  97                 sd_bus *bus,
  98                 const char *path,
  99                 const char *interface,
 100                 const char *property,
 101                 sd_bus_message *reply,
 102                 void *userdata,
 103                 sd_bus_error *error) {
 104
 105         Socket *s = SOCKET(userdata);
 106
 107         assert(bus);
 108         assert(reply);
 109         assert(s);
 110
 111         return sd_bus_message_append(reply, "s", socket_fdname(s));
 112 }
 113
 114 const sd_bus_vtable bus_socket_vtable[] = {
 115         SD_BUS_VTABLE_START(0),
 116         SD_BUS_PROPERTY("BindIPv6Only", "s", property_get_bind_ipv6_only, offsetof(Socket, bind_ipv6_only), SD_BUS_VTABLE_PROPERTY_CONST),
 117         SD_BUS_PROPERTY("Backlog", "u", bus_property_get_unsigned, offsetof(Socket, backlog), SD_BUS_VTABLE_PROPERTY_CONST),
 118         SD_BUS_PROPERTY("TimeoutUSec", "t", bus_property_get_usec, offsetof(Socket, timeout_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 119         SD_BUS_PROPERTY("BindToDevice", "s", NULL, offsetof(Socket, bind_to_device), SD_BUS_VTABLE_PROPERTY_CONST),
 120         SD_BUS_PROPERTY("SocketUser", "s", NULL, offsetof(Socket, user), SD_BUS_VTABLE_PROPERTY_CONST),
 121         SD_BUS_PROPERTY("SocketGroup", "s", NULL, offsetof(Socket, group), SD_BUS_VTABLE_PROPERTY_CONST),
 122         SD_BUS_PROPERTY("SocketMode", "u", bus_property_get_mode, offsetof(Socket, socket_mode), SD_BUS_VTABLE_PROPERTY_CONST),
 123         SD_BUS_PROPERTY("DirectoryMode", "u", bus_property_get_mode, offsetof(Socket, directory_mode), SD_BUS_VTABLE_PROPERTY_CONST),
 124         SD_BUS_PROPERTY("Accept", "b", bus_property_get_bool, offsetof(Socket, accept), SD_BUS_VTABLE_PROPERTY_CONST),
 125         SD_BUS_PROPERTY("Writable", "b", bus_property_get_bool, offsetof(Socket, writable), SD_BUS_VTABLE_PROPERTY_CONST),
 126         SD_BUS_PROPERTY("KeepAlive", "b", bus_property_get_bool, offsetof(Socket, keep_alive), SD_BUS_VTABLE_PROPERTY_CONST),
 127         SD_BUS_PROPERTY("KeepAliveTimeUSec", "t", bus_property_get_usec, offsetof(Socket, keep_alive_time), SD_BUS_VTABLE_PROPERTY_CONST),
 128         SD_BUS_PROPERTY("KeepAliveIntervalUSec", "t", bus_property_get_usec, offsetof(Socket, keep_alive_interval), SD_BUS_VTABLE_PROPERTY_CONST),
 129         SD_BUS_PROPERTY("KeepAliveProbes", "u", bus_property_get_unsigned, offsetof(Socket, keep_alive_cnt), SD_BUS_VTABLE_PROPERTY_CONST),
 130         SD_BUS_PROPERTY("DeferAcceptUSec" , "t", bus_property_get_usec, offsetof(Socket, defer_accept), SD_BUS_VTABLE_PROPERTY_CONST),
 131         SD_BUS_PROPERTY("NoDelay", "b", bus_property_get_bool, offsetof(Socket, no_delay), SD_BUS_VTABLE_PROPERTY_CONST),
 132         SD_BUS_PROPERTY("Priority", "i", bus_property_get_int, offsetof(Socket, priority), SD_BUS_VTABLE_PROPERTY_CONST),
 133         SD_BUS_PROPERTY("ReceiveBuffer", "t", bus_property_get_size, offsetof(Socket, receive_buffer), SD_BUS_VTABLE_PROPERTY_CONST),
 134         SD_BUS_PROPERTY("SendBuffer", "t", bus_property_get_size, offsetof(Socket, send_buffer), SD_BUS_VTABLE_PROPERTY_CONST),
 135         SD_BUS_PROPERTY("IPTOS", "i", bus_property_get_int, offsetof(Socket, ip_tos), SD_BUS_VTABLE_PROPERTY_CONST),
 136         SD_BUS_PROPERTY("IPTTL", "i", bus_property_get_int, offsetof(Socket, ip_ttl), SD_BUS_VTABLE_PROPERTY_CONST),
 137         SD_BUS_PROPERTY("PipeSize", "t", bus_property_get_size, offsetof(Socket, pipe_size), SD_BUS_VTABLE_PROPERTY_CONST),
 138         SD_BUS_PROPERTY("FreeBind", "b", bus_property_get_bool, offsetof(Socket, free_bind), SD_BUS_VTABLE_PROPERTY_CONST),
 139         SD_BUS_PROPERTY("Transparent", "b", bus_property_get_bool, offsetof(Socket, transparent), SD_BUS_VTABLE_PROPERTY_CONST),
 140         SD_BUS_PROPERTY("Broadcast", "b", bus_property_get_bool, offsetof(Socket, broadcast), SD_BUS_VTABLE_PROPERTY_CONST),
 141         SD_BUS_PROPERTY("PassCredentials", "b", bus_property_get_bool, offsetof(Socket, pass_cred), SD_BUS_VTABLE_PROPERTY_CONST),
 142         SD_BUS_PROPERTY("PassSecurity", "b", bus_property_get_bool, offsetof(Socket, pass_sec), SD_BUS_VTABLE_PROPERTY_CONST),
 143         SD_BUS_PROPERTY("RemoveOnStop", "b", bus_property_get_bool, offsetof(Socket, remove_on_stop), SD_BUS_VTABLE_PROPERTY_CONST),
 144         SD_BUS_PROPERTY("Listen", "a(ss)", property_get_listen, 0, SD_BUS_VTABLE_PROPERTY_CONST),
 145         SD_BUS_PROPERTY("Symlinks", "as", NULL, offsetof(Socket, symlinks), SD_BUS_VTABLE_PROPERTY_CONST),
 146         SD_BUS_PROPERTY("Mark", "i", bus_property_get_int, offsetof(Socket, mark), SD_BUS_VTABLE_PROPERTY_CONST),
 147         SD_BUS_PROPERTY("MaxConnections", "u", bus_property_get_unsigned, offsetof(Socket, max_connections), SD_BUS_VTABLE_PROPERTY_CONST),
 148         SD_BUS_PROPERTY("MaxConnectionsPerSource", "u", bus_property_get_unsigned, offsetof(Socket, max_connections_per_source), SD_BUS_VTABLE_PROPERTY_CONST),
 149         SD_BUS_PROPERTY("MessageQueueMaxMessages", "x", bus_property_get_long, offsetof(Socket, mq_maxmsg), SD_BUS_VTABLE_PROPERTY_CONST),
 150         SD_BUS_PROPERTY("MessageQueueMessageSize", "x", bus_property_get_long, offsetof(Socket, mq_msgsize), SD_BUS_VTABLE_PROPERTY_CONST),
 151         SD_BUS_PROPERTY("TCPCongestion", "s", NULL, offsetof(Socket, tcp_congestion), SD_BUS_VTABLE_PROPERTY_CONST),
 152         SD_BUS_PROPERTY("ReusePort", "b",  bus_property_get_bool, offsetof(Socket, reuse_port), SD_BUS_VTABLE_PROPERTY_CONST),
 153         SD_BUS_PROPERTY("SmackLabel", "s", NULL, offsetof(Socket, smack), SD_BUS_VTABLE_PROPERTY_CONST),
 154         SD_BUS_PROPERTY("SmackLabelIPIn", "s", NULL, offsetof(Socket, smack_ip_in), SD_BUS_VTABLE_PROPERTY_CONST),
 155         SD_BUS_PROPERTY("SmackLabelIPOut", "s", NULL, offsetof(Socket, smack_ip_out), SD_BUS_VTABLE_PROPERTY_CONST),
 156         SD_BUS_PROPERTY("ControlPID", "u", bus_property_get_pid, offsetof(Socket, control_pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 157         SD_BUS_PROPERTY("Result", "s", property_get_result, offsetof(Socket, result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 158         SD_BUS_PROPERTY("NConnections", "u", bus_property_get_unsigned, offsetof(Socket, n_connections), 0),
 159         SD_BUS_PROPERTY("NAccepted", "u", bus_property_get_unsigned, offsetof(Socket, n_accepted), 0),
 160         SD_BUS_PROPERTY("FileDescriptorName", "s", property_get_fdname, 0, 0),
 161         SD_BUS_PROPERTY("SocketProtocol", "i", bus_property_get_int, offsetof(Socket, socket_protocol), SD_BUS_VTABLE_PROPERTY_CONST),
 162         SD_BUS_PROPERTY("TriggerLimitIntervalUSec", "t", bus_property_get_usec, offsetof(Socket, trigger_limit.interval), SD_BUS_VTABLE_PROPERTY_CONST),
 163         SD_BUS_PROPERTY("TriggerLimitBurst", "u", bus_property_get_unsigned, offsetof(Socket, trigger_limit.burst), SD_BUS_VTABLE_PROPERTY_CONST),
 164         SD_BUS_PROPERTY("UID", "u", NULL, offsetof(Unit, ref_uid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 165         SD_BUS_PROPERTY("GID", "u", NULL, offsetof(Unit, ref_gid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 166         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPre", offsetof(Socket, exec_command[SOCKET_EXEC_START_PRE]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 167         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPost", offsetof(Socket, exec_command[SOCKET_EXEC_START_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 168         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStopPre", offsetof(Socket, exec_command[SOCKET_EXEC_STOP_PRE]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 169         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStopPost", offsetof(Socket, exec_command[SOCKET_EXEC_STOP_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 170         SD_BUS_VTABLE_END
 171 };
 172
 173 static inline bool check_size_t_truncation(uint64_t t) {
 174         return (size_t) t == t;
 175 }
 176
 177 static inline const char* socket_protocol_to_name_supported(int32_t i) {
 178         if (!IN_SET(i, IPPROTO_UDPLITE, IPPROTO_SCTP))
 179                 return NULL;
 180
 181         return socket_protocol_to_name(i);
 182 }
 183
 184 static BUS_DEFINE_SET_TRANSIENT(int, "i", int32_t, int, "%" PRIi32);
 185 static BUS_DEFINE_SET_TRANSIENT(message_queue, "x", int64_t, long, "%" PRIi64);
 186 static BUS_DEFINE_SET_TRANSIENT_IS_VALID(size_t_check_truncation, "t", uint64_t, size_t, "%" PRIu64, check_size_t_truncation);
 187 static BUS_DEFINE_SET_TRANSIENT_PARSE(bind_ipv6_only, SocketAddressBindIPv6Only, parse_socket_address_bind_ipv6_only_or_bool);
 188 static BUS_DEFINE_SET_TRANSIENT_STRING_WITH_CHECK(fdname, fdname_is_valid);
 189 static BUS_DEFINE_SET_TRANSIENT_STRING_WITH_CHECK(ifname, ifname_valid);
 190 static BUS_DEFINE_SET_TRANSIENT_TO_STRING_ALLOC(ip_tos, "i", int32_t, int, "%" PRIi32, ip_tos_to_string_alloc);
 191 static BUS_DEFINE_SET_TRANSIENT_TO_STRING(socket_protocol, "i", int32_t, int, "%" PRIi32, socket_protocol_to_name_supported);
 192
 193 static int bus_socket_set_transient_property(
 194                 Socket *s,
 195                 const char *name,
 196                 sd_bus_message *message,
 197                 UnitWriteFlags flags,
 198                 sd_bus_error *error) {
 199
 200         SocketExecCommand ci;
 201         Unit *u = UNIT(s);
 202         int r;
 203
 204         assert(s);
 205         assert(name);
 206         assert(message);
 207
 208         flags |= UNIT_PRIVATE;
 209
 210         if (streq(name, "Accept"))
 211                 return bus_set_transient_bool(u, name, &s->accept, message, flags, error);
 212
 213         if (streq(name, "Writable"))
 214                 return bus_set_transient_bool(u, name, &s->writable, message, flags, error);
 215
 216         if (streq(name, "KeepAlive"))
 217                 return bus_set_transient_bool(u, name, &s->keep_alive, message, flags, error);
 218
 219         if (streq(name, "NoDelay"))
 220                 return bus_set_transient_bool(u, name, &s->no_delay, message, flags, error);
 221
 222         if (streq(name, "FreeBind"))
 223                 return bus_set_transient_bool(u, name, &s->free_bind, message, flags, error);
 224
 225         if (streq(name, "Transparent"))
 226                 return bus_set_transient_bool(u, name, &s->transparent, message, flags, error);
 227
 228         if (streq(name, "Broadcast"))
 229                 return bus_set_transient_bool(u, name, &s->broadcast, message, flags, error);
 230
 231         if (streq(name, "PassCredentials"))
 232                 return bus_set_transient_bool(u, name, &s->pass_cred, message, flags, error);
 233
 234         if (streq(name, "PassSecurity"))
 235                 return bus_set_transient_bool(u, name, &s->pass_sec, message, flags, error);
 236
 237         if (streq(name, "ReusePort"))
 238                 return bus_set_transient_bool(u, name, &s->reuse_port, message, flags, error);
 239
 240         if (streq(name, "RemoveOnStop"))
 241                 return bus_set_transient_bool(u, name, &s->remove_on_stop, message, flags, error);
 242
 243         if (streq(name, "SELinuxContextFromNet"))
 244                 return bus_set_transient_bool(u, name, &s->selinux_context_from_net, message, flags, error);
 245
 246         if (streq(name, "Priority"))
 247                 return bus_set_transient_int(u, name, &s->priority, message, flags, error);
 248
 249         if (streq(name, "IPTTL"))
 250                 return bus_set_transient_int(u, name, &s->ip_ttl, message, flags, error);
 251
 252         if (streq(name, "Mark"))
 253                 return bus_set_transient_int(u, name, &s->mark, message, flags, error);
 254
 255         if (streq(name, "Backlog"))
 256                 return bus_set_transient_unsigned(u, name, &s->backlog, message, flags, error);
 257
 258         if (streq(name, "MaxConnections"))
 259                 return bus_set_transient_unsigned(u, name, &s->max_connections, message, flags, error);
 260
 261         if (streq(name, "MaxConnectionsPerSource"))
 262                 return bus_set_transient_unsigned(u, name, &s->max_connections_per_source, message, flags, error);
 263
 264         if (streq(name, "KeepAliveProbes"))
 265                 return bus_set_transient_unsigned(u, name, &s->keep_alive_cnt, message, flags, error);
 266
 267         if (streq(name, "TriggerLimitBurst"))
 268                 return bus_set_transient_unsigned(u, name, &s->trigger_limit.burst, message, flags, error);
 269
 270         if (streq(name, "SocketMode"))
 271                 return bus_set_transient_mode_t(u, name, &s->socket_mode, message, flags, error);
 272
 273         if (streq(name, "DirectoryMode"))
 274                 return bus_set_transient_mode_t(u, name, &s->directory_mode, message, flags, error);
 275
 276         if (streq(name, "MessageQueueMaxMessages"))
 277                 return bus_set_transient_message_queue(u, name, &s->mq_maxmsg, message, flags, error);
 278
 279         if (streq(name, "MessageQueueMessageSize"))
 280                 return bus_set_transient_message_queue(u, name, &s->mq_msgsize, message, flags, error);
 281
 282         if (streq(name, "TimeoutUSec"))
 283                 return bus_set_transient_usec_fix_0(u, name, &s->timeout_usec, message, flags, error);
 284
 285         if (streq(name, "KeepAliveTimeUSec"))
 286                 return bus_set_transient_usec(u, name, &s->keep_alive_time, message, flags, error);
 287
 288         if (streq(name, "KeepAliveIntervalUSec"))
 289                 return bus_set_transient_usec(u, name, &s->keep_alive_interval, message, flags, error);
 290
 291         if (streq(name, "DeferAcceptUSec"))
 292                 return bus_set_transient_usec(u, name, &s->defer_accept, message, flags, error);
 293
 294         if (streq(name, "TriggerLimitIntervalUSec"))
 295                 return bus_set_transient_usec(u, name, &s->trigger_limit.interval, message, flags, error);
 296
 297         if (streq(name, "SmackLabel"))
 298                 return bus_set_transient_string(u, name, &s->smack, message, flags, error);
 299
 300         if (streq(name, "SmackLabelIPin"))
 301                 return bus_set_transient_string(u, name, &s->smack_ip_in, message, flags, error);
 302
 303         if (streq(name, "SmackLabelIPOut"))
 304                 return bus_set_transient_string(u, name, &s->smack_ip_out, message, flags, error);
 305
 306         if (streq(name, "TCPCongestion"))
 307                 return bus_set_transient_string(u, name, &s->tcp_congestion, message, flags, error);
 308
 309         if (streq(name, "FileDescriptorName"))
 310                 return bus_set_transient_fdname(u, name, &s->fdname, message, flags, error);
 311
 312         if (streq(name, "SocketUser"))
 313                 return bus_set_transient_user(u, name, &s->user, message, flags, error);
 314
 315         if (streq(name, "SocketGroup"))
 316                 return bus_set_transient_user(u, name, &s->group, message, flags, error);
 317
 318         if (streq(name, "BindIPv6Only"))
 319                 return bus_set_transient_bind_ipv6_only(u, name, &s->bind_ipv6_only, message, flags, error);
 320
 321         if (streq(name, "ReceiveBuffer"))
 322                 return bus_set_transient_size_t_check_truncation(u, name, &s->receive_buffer, message, flags, error);
 323
 324         if (streq(name, "SendBuffer"))
 325                 return bus_set_transient_size_t_check_truncation(u, name, &s->send_buffer, message, flags, error);
 326
 327         if (streq(name, "PipeSize"))
 328                 return bus_set_transient_size_t_check_truncation(u, name, &s->pipe_size, message, flags, error);
 329
 330         if (streq(name, "BindToDevice"))
 331                 return bus_set_transient_ifname(u, name, &s->bind_to_device, message, flags, error);
 332
 333         if (streq(name, "IPTOS"))
 334                 return bus_set_transient_ip_tos(u, name, &s->ip_tos, message, flags, error);
 335
 336         if (streq(name, "SocketProtocol"))
 337                 return bus_set_transient_socket_protocol(u, name, &s->socket_protocol, message, flags, error);
 338
 339         if ((ci = socket_exec_command_from_string(name)) >= 0)
 340                 return bus_set_transient_exec_command(u, name, &s->exec_command[ci], message, flags, error);
 341
 342         if (streq(name, "Symlinks")) {
 343                 _cleanup_strv_free_ char **l = NULL;
 344                 char **p;
 345
 346                 r = sd_bus_message_read_strv(message, &l);
 347                 if (r < 0)
 348                         return r;
 349
 350                 STRV_FOREACH(p, l) {
 351                         if (!path_is_absolute(*p))
 352                                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Symlink path is not absolute: %s", *p);
 353                 }
 354
 355                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
 356                         if (strv_isempty(l)) {
 357                                 s->symlinks = strv_free(s->symlinks);
 358                                 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "%s=", name);
 359                         } else {
 360                                 _cleanup_free_ char *joined = NULL;
 361
 362                                 r = strv_extend_strv(&s->symlinks, l, true);
 363                                 if (r < 0)
 364                                         return -ENOMEM;
 365
 366                                 joined = strv_join(l, " ");
 367                                 if (!joined)
 368                                         return -ENOMEM;
 369
 370                                 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "%s=%s", name, joined);
 371                         }
 372                 }
 373
 374                 return 1;
 375
 376         } else if (streq(name, "Listen")) {
 377                 const char *t, *a;
 378                 bool empty = true;
 379
 380                 r = sd_bus_message_enter_container(message, 'a', "(ss)");
 381                 if (r < 0)
 382                         return r;
 383
 384                 while ((r = sd_bus_message_read(message, "(ss)", &t, &a)) > 0) {
 385                         _cleanup_free_ SocketPort *p = NULL;
 386
 387                         p = new0(SocketPort, 1);
 388                         if (!p)
 389                                 return log_oom();
 390
 391                         p->type = socket_port_type_from_string(t);
 392                         if (p->type < 0)
 393                                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown Socket type: %s", t);
 394
 395                         if (p->type != SOCKET_SOCKET) {
 396                                 p->path = strdup(a);
 397                                 path_kill_slashes(p->path);
 398
 399                         } else if (streq(t, "Netlink")) {
 400                                 r = socket_address_parse_netlink(&p->address, a);
 401                                 if (r < 0)
 402                                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid netlink address: %s", a);
 403
 404                         } else {
 405                                 r = socket_address_parse(&p->address, a);
 406                                 if (r < 0)
 407                                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid address: %s", a);
 408
 409                                 p->address.type = socket_address_type_from_string(t);
 410                                 if (p->address.type < 0)
 411                                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid address type: %s", t);
 412
 413                                 if (socket_address_family(&p->address) != AF_LOCAL && p->address.type == SOCK_SEQPACKET)
 414                                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Address family not supported: %s", a);
 415                         }
 416
 417                         p->fd = -1;
 418                         p->auxiliary_fds = NULL;
 419                         p->n_auxiliary_fds = 0;
 420                         p->socket = s;
 421
 422                         empty = false;
 423
 424                         if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
 425                                 SocketPort *tail;
 426
 427                                 LIST_FIND_TAIL(port, s->ports, tail);
 428                                 LIST_INSERT_AFTER(port, s->ports, tail, p);
 429
 430                                 p = NULL;
 431
 432                                 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "Listen%s=%s", t, a);
 433                         }
 434                 }
 435                 if (r < 0)
 436                         return r;
 437
 438                 r = sd_bus_message_exit_container(message);
 439                 if (r < 0)
 440                         return r;
 441
 442                 if (!UNIT_WRITE_FLAGS_NOOP(flags) && empty) {
 443                         socket_free_ports(s);
 444                         unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "ListenStream=");
 445                 }
 446
 447                 return 1;
 448         }
 449
 450         return 0;
 451 }
 452
 453 int bus_socket_set_property(
 454                 Unit *u,
 455                 const char *name,
 456                 sd_bus_message *message,
 457                 UnitWriteFlags flags,
 458                 sd_bus_error *error) {
 459
 460         Socket *s = SOCKET(u);
 461         int r;
 462
 463         assert(s);
 464         assert(name);
 465         assert(message);
 466
 467         assert(s);
 468         assert(name);
 469         assert(message);
 470
 471         r = bus_cgroup_set_property(u, &s->cgroup_context, name, message, flags, error);
 472         if (r != 0)
 473                 return r;
 474
 475         if (u->transient && u->load_state == UNIT_STUB) {
 476                 /* This is a transient unit, let's load a little more */
 477
 478                 r = bus_socket_set_transient_property(s, name, message, flags, error);
 479                 if (r != 0)
 480                         return r;
 481
 482                 r = bus_exec_context_set_transient_property(u, &s->exec_context, name, message, flags, error);
 483                 if (r != 0)
 484                         return r;
 485
 486                 r = bus_kill_context_set_transient_property(u, &s->kill_context, name, message, flags, error);
 487                 if (r != 0)
 488                         return r;
 489         }
 490
 491         return 0;
 492 }
 493
 494 int bus_socket_commit_properties(Unit *u) {
 495         assert(u);
 496
 497         unit_update_cgroup_members_masks(u);
 498         unit_realize_cgroup(u);
 499
 500         return 0;
 501 }