]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/core/socket.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
networkd: make all calls async
[thirdparty/systemd.git] / src / core / socket.c
CommitLineData
d6c9574f 1/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
5cb5a6ff 2
a7334b09
LP		 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
5430f7f2
LP		 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
a7334b09
LP		 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
5430f7f2 16 Lesser General Public License for more details.
a7334b09 17
5430f7f2 18 You should have received a copy of the GNU Lesser General Public License
a7334b09
LP		 19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20***/
21
83c60c9f
LP		 22#include <sys/types.h>
23#include <sys/stat.h>
24#include <unistd.h>
25#include <errno.h>
26#include <fcntl.h>
f94ea366 27#include <sys/epoll.h>
034c6ed7 28#include <signal.h>
4f2d528d 29#include <arpa/inet.h>
916abb21 30#include <mqueue.h>
b00ad20f 31#ifdef HAVE_XATTR
0eb59ccf 32#include <attr/xattr.h>
cf37cd2f 33#endif
83c60c9f 34
87f0e418 35#include "unit.h"
5cb5a6ff 36#include "socket.h"
cebf8b20 37#include "netinet/tcp.h"
83c60c9f 38#include "log.h"
23a177ef
LP		 39#include "load-dropin.h"
40#include "load-fragment.h"
9e2f7c11 41#include "strv.h"
49e942b2 42#include "mkdir.h"
9eb977db 43#include "path-util.h"
4f2d528d 44#include "unit-name.h"
41f9172f 45#include "unit-printf.h"
4139c1b2 46#include "dbus-socket.h"
4fd5948e 47#include "missing.h"
a40eb732 48#include "special.h"
449101fc 49#include "dbus-common.h"
e51bc1a2 50#include "label.h"
9a57c629 51#include "exit-status.h"
f6a6225e 52#include "def.h"
5a045dad 53#include "smack-util.h"
83c60c9f 54
acbb0225 55static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
87f0e418
LP		 56 [SOCKET_DEAD] = UNIT_INACTIVE,
57 [SOCKET_START_PRE] = UNIT_ACTIVATING,
58 [SOCKET_START_POST] = UNIT_ACTIVATING,
59 [SOCKET_LISTENING] = UNIT_ACTIVE,
60 [SOCKET_RUNNING] = UNIT_ACTIVE,
61 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
62 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
63 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
64 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
80876c20
LP		 65 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
66 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
fdf20a31 67 [SOCKET_FAILED] = UNIT_FAILED
83c60c9f 68};
5cb5a6ff 69
a16e1123
LP		 70static void socket_init(Unit *u) {
71 Socket *s = SOCKET(u);
72
73 assert(u);
ac155bb8 74 assert(u->load_state == UNIT_STUB);
a16e1123 75
a16e1123 76 s->backlog = SOMAXCONN;
1f19a534 77 s->timeout_usec = u->manager->default_timeout_start_usec;
a16e1123 78 s->directory_mode = 0755;
9131f660 79 s->socket_mode = 0666;
a16e1123 80
6cf6bbc2
LP		 81 s->max_connections = 64;
82
4fd5948e 83 s->priority = -1;
4fd5948e
LP		 84 s->ip_tos = -1;
85 s->ip_ttl = -1;
4fd5948e 86 s->mark = -1;
4fd5948e 87
a16e1123 88 exec_context_init(&s->exec_context);
ac155bb8
MS		 89 s->exec_context.std_output = u->manager->default_std_output;
90 s->exec_context.std_error = u->manager->default_std_error;
4819ff03 91 kill_context_init(&s->kill_context);
4ad49000 92 cgroup_context_init(&s->cgroup_context);
a16e1123
LP		 93
94 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
95}
acbb0225 96
5e94833f
LP		 97static void socket_unwatch_control_pid(Socket *s) {
98 assert(s);
99
100 if (s->control_pid <= 0)
101 return;
102
103 unit_unwatch_pid(UNIT(s), s->control_pid);
104 s->control_pid = 0;
105}
106
74051b9b 107void socket_free_ports(Socket *s) {
034c6ed7
LP		 108 SocketPort *p;
109
110 assert(s);
111
112 while ((p = s->ports)) {
71fda00f 113 LIST_REMOVE(port, s->ports, p);
034c6ed7 114
a16e1123
LP		 115 if (p->fd >= 0) {
116 unit_unwatch_fd(UNIT(s), &p->fd_watch);
117 close_nointr_nofail(p->fd);
118 }
119
034c6ed7
LP		 120 free(p->path);
121 free(p);
122 }
74051b9b
LP		 123}
124
125static void socket_done(Unit *u) {
126 Socket *s = SOCKET(u);
127
128 assert(s);
129
130 socket_free_ports(s);
034c6ed7 131
c17ec25e 132 exec_context_done(&s->exec_context, manager_is_reloading_or_reexecuting(u->manager));
4ad49000
LP		 133 cgroup_context_init(&s->cgroup_context);
134
e537352b 135 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
034c6ed7
LP		 136 s->control_command = NULL;
137
5e94833f 138 socket_unwatch_control_pid(s);
034c6ed7 139
57020a3a 140 unit_ref_unset(&s->service);
034c6ed7 141
cebf8b20
TT		 142 free(s->tcp_congestion);
143 s->tcp_congestion = NULL;
144
acbb0225 145 free(s->bind_to_device);
e537352b 146 s->bind_to_device = NULL;
acbb0225 147
0eb59ccf
AK		 148 free(s->smack);
149 free(s->smack_ip_in);
150 free(s->smack_ip_out);
151
acbb0225 152 unit_unwatch_timer(u, &s->timer_watch);
5cb5a6ff
LP		 153}
154
b15bdda8
LP		 155static int socket_instantiate_service(Socket *s) {
156 char *prefix, *name;
157 int r;
158 Unit *u;
159
160 assert(s);
161
162 /* This fills in s->service if it isn't filled in yet. For
163 * Accept=yes sockets we create the next connection service
164 * here. For Accept=no this is mostly a NOP since the service
165 * is figured out at load time anyway. */
166
57020a3a 167 if (UNIT_DEREF(s->service))
b15bdda8
LP		 168 return 0;
169
170 assert(s->accept);
171
1124fe6f 172 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
b15bdda8
LP		 173 return -ENOMEM;
174
175 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
176 free(prefix);
177
178 if (r < 0)
179 return -ENOMEM;
180
1124fe6f 181 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
b15bdda8
LP		 182 free(name);
183
184 if (r < 0)
185 return r;
186
7b4bf06b 187#ifdef HAVE_SYSV_COMPAT
1b64d026 188 if (SERVICE(u)->is_sysv) {
7b4bf06b
LP		 189 log_error("Using SysV services for socket activation is not supported. Refusing.");
190 return -ENOENT;
191 }
192#endif
193
ac155bb8 194 u->no_gc = true;
57020a3a
LP		 195 unit_ref_set(&s->service, u);
196
197 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
b15bdda8
LP		 198}
199
4f2d528d
LP		 200static bool have_non_accept_socket(Socket *s) {
201 SocketPort *p;
202
203 assert(s);
204
205 if (!s->accept)
206 return true;
207
dd5ad9d4
LP		 208 LIST_FOREACH(port, p, s->ports) {
209
210 if (p->type != SOCKET_SOCKET)
211 return true;
212
4f2d528d
LP		 213 if (!socket_address_can_accept(&p->address))
214 return true;
dd5ad9d4 215 }
4f2d528d
LP		 216
217 return false;
218}
219
220static int socket_verify(Socket *s) {
221 assert(s);
222
1124fe6f 223 if (UNIT(s)->load_state != UNIT_LOADED)
4f2d528d
LP		 224 return 0;
225
226 if (!s->ports) {
66870f90
ZJS		 227 log_error_unit(UNIT(s)->id,
228 "%s lacks Listen setting. Refusing.", UNIT(s)->id);
4f2d528d
LP		 229 return -EINVAL;
230 }
231
0009d2a6 232 if (s->accept && have_non_accept_socket(s)) {
66870f90
ZJS		 233 log_error_unit(UNIT(s)->id,
234 "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
235 UNIT(s)->id);
0009d2a6
LP		 236 return -EINVAL;
237 }
238
6cf6bbc2 239 if (s->accept && s->max_connections <= 0) {
66870f90
ZJS		 240 log_error_unit(UNIT(s)->id,
241 "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
4d0e5dbd
LP		 242 return -EINVAL;
243 }
244
57020a3a 245 if (s->accept && UNIT_DEREF(s->service)) {
66870f90
ZJS		 246 log_error_unit(UNIT(s)->id,
247 "Explicit service configuration for accepting sockets not supported on %s. Refusing.",
248 UNIT(s)->id);
d9ff321a
LP		 249 return -EINVAL;
250 }
251
4819ff03 252 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
66870f90
ZJS		 253 log_error_unit(UNIT(s)->id,
254 "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.",
255 UNIT(s)->id);
6cf6bbc2
LP		 256 return -EINVAL;
257 }
258
4f2d528d
LP		 259 return 0;
260}
261
a57f7e2c 262static int socket_add_mount_links(Socket *s) {
6e2ef85b 263 SocketPort *p;
6e2ef85b
LP		 264 int r;
265
266 assert(s);
6e2ef85b 267
a57f7e2c
LP		 268 LIST_FOREACH(port, p, s->ports) {
269 const char *path = NULL;
6e2ef85b 270
a57f7e2c
LP		 271 if (p->type == SOCKET_SOCKET)
272 path = socket_address_get_path(&p->address);
273 else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL)
274 path = p->path;
6e2ef85b 275
a57f7e2c
LP		 276 if (!path)
277 continue;
6e2ef85b 278
a57f7e2c 279 r = unit_require_mounts_for(UNIT(s), path);
b87705cd 280 if (r < 0)
6e2ef85b 281 return r;
b87705cd 282 }
6e2ef85b
LP		 283
284 return 0;
285}
286
287static int socket_add_device_link(Socket *s) {
288 char *t;
289 int r;
290
291 assert(s);
292
7d0c710d 293 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
6e2ef85b
LP		 294 return 0;
295
296 if (asprintf(&t, "/sys/subsystem/net/devices/%s", s->bind_to_device) < 0)
297 return -ENOMEM;
298
299 r = unit_add_node_link(UNIT(s), t, false);
300 free(t);
301
302 return r;
303}
304
a40eb732
LP		 305static int socket_add_default_dependencies(Socket *s) {
306 int r;
307 assert(s);
308
e3d84721
LP		 309 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
310 if (r < 0)
311 return r;
2a77d31d 312
e3d84721
LP		 313 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
314 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
315 if (r < 0)
a40eb732 316 return r;
2a77d31d 317 }
a40eb732 318
ead8e478 319 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
a40eb732
LP		 320}
321
44a6b1b6 322_pure_ static bool socket_has_exec(Socket *s) {
4cfc6dbe
LP		 323 unsigned i;
324 assert(s);
325
326 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
327 if (s->exec_command[i])
328 return true;
329
330 return false;
331}
332
e537352b
LP		 333static int socket_load(Unit *u) {
334 Socket *s = SOCKET(u);
335 int r;
44d8db9e 336
e537352b 337 assert(u);
ac155bb8 338 assert(u->load_state == UNIT_STUB);
44d8db9e 339
e537352b 340 if ((r = unit_load_fragment_and_dropin(u)) < 0)
23a177ef 341 return r;
44d8db9e 342
23a177ef 343 /* This is a new unit? Then let's add in some extras */
ac155bb8 344 if (u->load_state == UNIT_LOADED) {
44d8db9e 345
4f2d528d 346 if (have_non_accept_socket(s)) {
d9ff321a 347
57020a3a
LP		 348 if (!UNIT_DEREF(s->service)) {
349 Unit *x;
350
351 r = unit_load_related_unit(u, ".service", &x);
352 if (r < 0)
d9ff321a 353 return r;
23a177ef 354
57020a3a
LP		 355 unit_ref_set(&s->service, x);
356 }
357
358 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
359 if (r < 0)
4f2d528d
LP		 360 return r;
361 }
44d8db9e 362
6e2ef85b
LP		 363 if ((r = socket_add_mount_links(s)) < 0)
364 return r;
365
366 if ((r = socket_add_device_link(s)) < 0)
367 return r;
368
4cfc6dbe
LP		 369 if (socket_has_exec(s))
370 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
371 return r;
23a177ef 372
a016b922
LP		 373 r = unit_add_default_slice(u);
374 if (r < 0)
375 return r;
376
1124fe6f 377 if (UNIT(s)->default_dependencies)
a40eb732
LP		 378 if ((r = socket_add_default_dependencies(s)) < 0)
379 return r;
e06c73cc 380
cba6e062 381 r = unit_exec_context_defaults(u, &s->exec_context);
e06c73cc
LP		 382 if (r < 0)
383 return r;
23a177ef
LP		 384 }
385
4f2d528d 386 return socket_verify(s);
44d8db9e
LP		 387}
388
44a6b1b6 389_const_ static const char* listen_lookup(int family, int type) {
7a22745a
LP		 390
391 if (family == AF_NETLINK)
392 return "ListenNetlink";
542563ba
LP		 393
394 if (type == SOCK_STREAM)
395 return "ListenStream";
396 else if (type == SOCK_DGRAM)
397 return "ListenDatagram";
398 else if (type == SOCK_SEQPACKET)
399 return "ListenSequentialPacket";
400
034c6ed7 401 assert_not_reached("Unknown socket type");
542563ba
LP		 402 return NULL;
403}
404
87f0e418 405static void socket_dump(Unit *u, FILE *f, const char *prefix) {
5cb5a6ff 406
5cb5a6ff 407 SocketExecCommand c;
87f0e418 408 Socket *s = SOCKET(u);
542563ba 409 SocketPort *p;
82ba9f08
LP		 410 const char *prefix2;
411 char *p2;
5cb5a6ff
LP		 412
413 assert(s);
fa068367 414 assert(f);
5cb5a6ff 415
82ba9f08
LP		 416 p2 = strappend(prefix, "\t");
417 prefix2 = p2 ? p2 : prefix;
c43d20a0 418
5cb5a6ff
LP		 419 fprintf(f,
420 "%sSocket State: %s\n"
81a5c6d0 421 "%sResult: %s\n"
542563ba 422 "%sBindIPv6Only: %s\n"
b5a0699f
LP		 423 "%sBacklog: %u\n"
424 "%sSocketMode: %04o\n"
4fd5948e
LP		 425 "%sDirectoryMode: %04o\n"
426 "%sKeepAlive: %s\n"
cebf8b20 427 "%sFreeBind: %s\n"
6b6d2dee 428 "%sTransparent: %s\n"
ec6370a2 429 "%sBroadcast: %s\n"
ede3deb4 430 "%sPassCredentials: %s\n"
54ecda32 431 "%sPassSecurity: %s\n"
cebf8b20 432 "%sTCPCongestion: %s\n",
a16e1123 433 prefix, socket_state_to_string(s->state),
81a5c6d0 434 prefix, socket_result_to_string(s->result),
c0120d99 435 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
b5a0699f
LP		 436 prefix, s->backlog,
437 prefix, s->socket_mode,
4fd5948e
LP		 438 prefix, s->directory_mode,
439 prefix, yes_no(s->keep_alive),
cebf8b20 440 prefix, yes_no(s->free_bind),
6b6d2dee 441 prefix, yes_no(s->transparent),
ec6370a2 442 prefix, yes_no(s->broadcast),
d68af586 443 prefix, yes_no(s->pass_cred),
54ecda32 444 prefix, yes_no(s->pass_sec),
83a95334 445 prefix, strna(s->tcp_congestion));
542563ba 446
70123e68
LP		 447 if (s->control_pid > 0)
448 fprintf(f,
bb00e604
LP		 449 "%sControl PID: %lu\n",
450 prefix, (unsigned long) s->control_pid);
70123e68 451
acbb0225
LP		 452 if (s->bind_to_device)
453 fprintf(f,
454 "%sBindToDevice: %s\n",
455 prefix, s->bind_to_device);
456
4f2d528d
LP		 457 if (s->accept)
458 fprintf(f,
6cf6bbc2
LP		 459 "%sAccepted: %u\n"
460 "%sNConnections: %u\n"
461 "%sMaxConnections: %u\n",
462 prefix, s->n_accepted,
463 prefix, s->n_connections,
464 prefix, s->max_connections);
4f2d528d 465
4fd5948e
LP		 466 if (s->priority >= 0)
467 fprintf(f,
468 "%sPriority: %i\n",
469 prefix, s->priority);
470
471 if (s->receive_buffer > 0)
472 fprintf(f,
473 "%sReceiveBuffer: %zu\n",
474 prefix, s->receive_buffer);
475
476 if (s->send_buffer > 0)
477 fprintf(f,
478 "%sSendBuffer: %zu\n",
479 prefix, s->send_buffer);
480
481 if (s->ip_tos >= 0)
482 fprintf(f,
483 "%sIPTOS: %i\n",
484 prefix, s->ip_tos);
485
486 if (s->ip_ttl >= 0)
487 fprintf(f,
488 "%sIPTTL: %i\n",
489 prefix, s->ip_ttl);
490
491 if (s->pipe_size > 0)
492 fprintf(f,
493 "%sPipeSize: %zu\n",
494 prefix, s->pipe_size);
495
496 if (s->mark >= 0)
497 fprintf(f,
498 "%sMark: %i\n",
499 prefix, s->mark);
500
916abb21
LP		 501 if (s->mq_maxmsg > 0)
502 fprintf(f,
503 "%sMessageQueueMaxMessages: %li\n",
504 prefix, s->mq_maxmsg);
505
506 if (s->mq_msgsize > 0)
507 fprintf(f,
508 "%sMessageQueueMessageSize: %li\n",
509 prefix, s->mq_msgsize);
510
f7db7a69
SL		 511 if (s->reuseport)
512 fprintf(f,
513 "%sReusePort: %s\n",
514 prefix, yes_no(s->reuseport));
515
0eb59ccf
AK		 516 if (s->smack)
517 fprintf(f,
518 "%sSmackLabel: %s\n",
519 prefix, s->smack);
520
521 if (s->smack_ip_in)
522 fprintf(f,
523 "%sSmackLabelIPIn: %s\n",
524 prefix, s->smack_ip_in);
525
526 if (s->smack_ip_out)
527 fprintf(f,
528 "%sSmackLabelIPOut: %s\n",
529 prefix, s->smack_ip_out);
530
034c6ed7 531 LIST_FOREACH(port, p, s->ports) {
5cb5a6ff 532
542563ba
LP		 533 if (p->type == SOCKET_SOCKET) {
534 const char *t;
535 int r;
e364ad06 536 char *k = NULL;
542563ba
LP		 537
538 if ((r = socket_address_print(&p->address, &k)) < 0)
539 t = strerror(-r);
540 else
541 t = k;
542
7a22745a 543 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
542563ba 544 free(k);
b0a3f2bc
LP		 545 } else if (p->type == SOCKET_SPECIAL)
546 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
916abb21
LP		 547 else if (p->type == SOCKET_MQUEUE)
548 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
b0a3f2bc 549 else
542563ba
LP		 550 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
551 }
5cb5a6ff
LP		 552
553 exec_context_dump(&s->exec_context, f, prefix);
4819ff03 554 kill_context_dump(&s->kill_context, f, prefix);
5cb5a6ff 555
e537352b 556 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
c43d20a0
LP		 557 if (!s->exec_command[c])
558 continue;
5cb5a6ff 559
40d50879 560 fprintf(f, "%s-> %s:\n",
a16e1123 561 prefix, socket_exec_command_to_string(c));
c43d20a0
LP		 562
563 exec_command_dump_list(s->exec_command[c], f, prefix2);
5cb5a6ff 564 }
c43d20a0 565
82ba9f08 566 free(p2);
5cb5a6ff
LP		 567}
568
4f2d528d
LP		 569static int instance_from_socket(int fd, unsigned nr, char **instance) {
570 socklen_t l;
571 char *r;
572 union {
573 struct sockaddr sa;
574 struct sockaddr_un un;
575 struct sockaddr_in in;
576 struct sockaddr_in6 in6;
577 struct sockaddr_storage storage;
578 } local, remote;
579
580 assert(fd >= 0);
581 assert(instance);
582
583 l = sizeof(local);
584 if (getsockname(fd, &local.sa, &l) < 0)
585 return -errno;
586
587 l = sizeof(remote);
588 if (getpeername(fd, &remote.sa, &l) < 0)
589 return -errno;
590
591 switch (local.sa.sa_family) {
592
593 case AF_INET: {
594 uint32_t
595 a = ntohl(local.in.sin_addr.s_addr),
596 b = ntohl(remote.in.sin_addr.s_addr);
597
598 if (asprintf(&r,
77b088c2
LP		 599 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
600 nr,
4f2d528d
LP		 601 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
602 ntohs(local.in.sin_port),
603 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
604 ntohs(remote.in.sin_port)) < 0)
605 return -ENOMEM;
606
607 break;
608 }
609
610 case AF_INET6: {
c65a0b14 611 static const unsigned char ipv4_prefix[] = {
2b061f5a
LP		 612 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
613 };
614
615 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
616 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
617 const uint8_t
618 *a = local.in6.sin6_addr.s6_addr+12,
619 *b = remote.in6.sin6_addr.s6_addr+12;
620
621 if (asprintf(&r,
77b088c2
LP		 622 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
623 nr,
2b061f5a
LP		 624 a[0], a[1], a[2], a[3],
625 ntohs(local.in6.sin6_port),
626 b[0], b[1], b[2], b[3],
627 ntohs(remote.in6.sin6_port)) < 0)
628 return -ENOMEM;
629 } else {
630 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
631
632 if (asprintf(&r,
77b088c2
LP		 633 "%u-%s:%u-%s:%u",
634 nr,
2b061f5a
LP		 635 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
636 ntohs(local.in6.sin6_port),
637 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
638 ntohs(remote.in6.sin6_port)) < 0)
639 return -ENOMEM;
640 }
4f2d528d
LP		 641
642 break;
643 }
644
645 case AF_UNIX: {
646 struct ucred ucred;
647
648 l = sizeof(ucred);
649 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
650 return -errno;
651
652 if (asprintf(&r,
bb00e604 653 "%u-%lu-%lu",
4f2d528d 654 nr,
bb00e604
LP		 655 (unsigned long) ucred.pid,
656 (unsigned long) ucred.uid) < 0)
4f2d528d
LP		 657 return -ENOMEM;
658
659 break;
660 }
661
662 default:
663 assert_not_reached("Unhandled socket type.");
664 }
665
666 *instance = r;
667 return 0;
668}
669
034c6ed7 670static void socket_close_fds(Socket *s) {
83c60c9f
LP		 671 SocketPort *p;
672
673 assert(s);
674
034c6ed7 675 LIST_FOREACH(port, p, s->ports) {
83c60c9f
LP		 676 if (p->fd < 0)
677 continue;
678
acbb0225 679 unit_unwatch_fd(UNIT(s), &p->fd_watch);
a16e1123
LP		 680 close_nointr_nofail(p->fd);
681
682 /* One little note: we should never delete any sockets
683 * in the file system here! After all some other
684 * process we spawned might still have a reference of
685 * this fd and wants to continue to use it. Therefore
686 * we delete sockets in the file system before we
687 * create a new one, not after we stopped using
688 * one! */
9152c765 689
83c60c9f
LP		 690 p->fd = -1;
691 }
692}
693
4fd5948e
LP		 694static void socket_apply_socket_options(Socket *s, int fd) {
695 assert(s);
696 assert(fd >= 0);
697
698 if (s->keep_alive) {
699 int b = s->keep_alive;
700 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
66870f90 701 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
4fd5948e
LP		 702 }
703
ec6370a2
LP		 704 if (s->broadcast) {
705 int one = 1;
706 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
66870f90 707 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
ec6370a2
LP		 708 }
709
d68af586
MS		 710 if (s->pass_cred) {
711 int one = 1;
712 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
66870f90 713 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
d68af586
MS		 714 }
715
54ecda32
LP		 716 if (s->pass_sec) {
717 int one = 1;
718 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
66870f90 719 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
54ecda32
LP		 720 }
721
4fd5948e
LP		 722 if (s->priority >= 0)
723 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
66870f90 724 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
4fd5948e
LP		 725
726 if (s->receive_buffer > 0) {
727 int value = (int) s->receive_buffer;
7d9eaa84
LP		 728
729 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
730
b8cef44e 731 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
7d9eaa84 732 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
66870f90 733 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
4fd5948e
LP		 734 }
735
736 if (s->send_buffer > 0) {
737 int value = (int) s->send_buffer;
b8cef44e 738 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
7d9eaa84 739 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
66870f90 740 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
4fd5948e
LP		 741 }
742
743 if (s->mark >= 0)
744 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
66870f90 745 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
4fd5948e
LP		 746
747 if (s->ip_tos >= 0)
748 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
66870f90 749 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
4fd5948e 750
46925ac5
LP		 751 if (s->ip_ttl >= 0) {
752 int r, x;
753
754 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
5bfcc1c6
FF		 755
756 if (socket_ipv6_is_supported())
757 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
758 else {
759 x = -1;
760 errno = EAFNOSUPPORT;
761 }
46925ac5
LP		 762
763 if (r < 0 && x < 0)
66870f90
ZJS		 764 log_warning_unit(UNIT(s)->id,
765 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
46925ac5 766 }
cebf8b20
TT		 767
768 if (s->tcp_congestion)
769 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
66870f90 770 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
0eb59ccf 771
f7db7a69
SL		 772 if (s->reuseport) {
773 int b = s->reuseport;
774 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)))
775 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
776 }
777
9a4e038c
KS		 778 if (s->smack_ip_in)
779 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
780 log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
781
782 if (s->smack_ip_out)
783 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
784 log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
4fd5948e
LP		 785}
786
b15bdda8 787static void socket_apply_fifo_options(Socket *s, int fd) {
4fd5948e
LP		 788 assert(s);
789 assert(fd >= 0);
790
791 if (s->pipe_size > 0)
792 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
66870f90
ZJS		 793 log_warning_unit(UNIT(s)->id,
794 "F_SETPIPE_SZ: %m");
0eb59ccf 795
9a4e038c
KS		 796 if (s->smack)
797 if (smack_label_fd(fd, s->smack) < 0)
798 log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
4fd5948e
LP		 799}
800
b15bdda8
LP		 801static int fifo_address_create(
802 const char *path,
803 mode_t directory_mode,
804 mode_t socket_mode,
b15bdda8
LP		 805 int *_fd) {
806
7a58bfa4 807 int fd = -1, r = 0;
b15bdda8
LP		 808 struct stat st;
809 mode_t old_mask;
810
811 assert(path);
812 assert(_fd);
813
d2e54fae 814 mkdir_parents_label(path, directory_mode);
b15bdda8 815
e9a5ef7c
KS		 816 r = label_context_set(path, S_IFIFO);
817 if (r < 0)
56cf987f 818 goto fail;
b15bdda8
LP		 819
820 /* Enforce the right access mode for the fifo */
821 old_mask = umask(~ socket_mode);
822
823 /* Include the original umask in our mask */
824 umask(~socket_mode | old_mask);
825
826 r = mkfifo(path, socket_mode);
827 umask(old_mask);
828
94bc2731 829 if (r < 0 && errno != EEXIST) {
b15bdda8
LP		 830 r = -errno;
831 goto fail;
832 }
833
e4f44e73 834 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
b15bdda8
LP		 835 r = -errno;
836 goto fail;
837 }
838
e9a5ef7c 839 label_context_clear();
7a58bfa4 840
b15bdda8
LP		 841 if (fstat(fd, &st) < 0) {
842 r = -errno;
843 goto fail;
844 }
845
846 if (!S_ISFIFO(st.st_mode) ||
de0200fc 847 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
e4f44e73
DR		 848 st.st_uid != getuid() ||
849 st.st_gid != getgid()) {
b15bdda8
LP		 850
851 r = -EEXIST;
852 goto fail;
853 }
854
855 *_fd = fd;
856 return 0;
857
858fail:
e9a5ef7c 859 label_context_clear();
56cf987f 860
b15bdda8
LP		 861 if (fd >= 0)
862 close_nointr_nofail(fd);
863
864 return r;
865}
866
b0a3f2bc
LP		 867static int special_address_create(
868 const char *path,
869 int *_fd) {
870
871 int fd = -1, r = 0;
872 struct stat st;
873
874 assert(path);
875 assert(_fd);
876
877 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
878 r = -errno;
879 goto fail;
880 }
881
882 if (fstat(fd, &st) < 0) {
883 r = -errno;
884 goto fail;
885 }
886
887 /* Check whether this is a /proc, /sys or /dev file or char device */
888 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
889 r = -EEXIST;
890 goto fail;
891 }
892
893 *_fd = fd;
894 return 0;
895
896fail:
897 if (fd >= 0)
898 close_nointr_nofail(fd);
899
900 return r;
901}
902
916abb21
LP		 903static int mq_address_create(
904 const char *path,
905 mode_t mq_mode,
906 long maxmsg,
907 long msgsize,
908 int *_fd) {
909
910 int fd = -1, r = 0;
911 struct stat st;
912 mode_t old_mask;
913 struct mq_attr _attr, *attr = NULL;
914
915 assert(path);
916 assert(_fd);
917
918 if (maxmsg > 0 && msgsize > 0) {
919 zero(_attr);
920 _attr.mq_flags = O_NONBLOCK;
921 _attr.mq_maxmsg = maxmsg;
922 _attr.mq_msgsize = msgsize;
923 attr = &_attr;
924 }
925
926 /* Enforce the right access mode for the mq */
927 old_mask = umask(~ mq_mode);
928
929 /* Include the original umask in our mask */
930 umask(~mq_mode | old_mask);
931
932 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
933 umask(old_mask);
934
8ea913b2 935 if (fd < 0) {
916abb21
LP		 936 r = -errno;
937 goto fail;
938 }
939
940 if (fstat(fd, &st) < 0) {
941 r = -errno;
942 goto fail;
943 }
944
945 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
946 st.st_uid != getuid() ||
947 st.st_gid != getgid()) {
948
949 r = -EEXIST;
950 goto fail;
951 }
952
953 *_fd = fd;
954 return 0;
955
956fail:
957 if (fd >= 0)
958 close_nointr_nofail(fd);
959
960 return r;
961}
962
034c6ed7 963static int socket_open_fds(Socket *s) {
83c60c9f
LP		 964 SocketPort *p;
965 int r;
56cf987f 966 char *label = NULL;
049f8642 967 bool know_label = false;
83c60c9f
LP		 968
969 assert(s);
970
034c6ed7 971 LIST_FOREACH(port, p, s->ports) {
83c60c9f 972
034c6ed7
LP		 973 if (p->fd >= 0)
974 continue;
83c60c9f
LP		 975
976 if (p->type == SOCKET_SOCKET) {
977
049f8642
LP		 978 if (!know_label) {
979
980 if ((r = socket_instantiate_service(s)) < 0)
981 return r;
982
9444b1f2 983 if (UNIT_ISSET(s->service) &&
57020a3a
LP		 984 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
985 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
189583d7
LP		 986
987 if (r < 0) {
a7444eda
LP		 988 if (r != -EPERM)
989 return r;
990 }
189583d7 991 }
049f8642
LP		 992
993 know_label = true;
994 }
995
175a3d25
LP		 996 r = socket_address_listen(
997 &p->address,
998 SOCK_CLOEXEC|SOCK_NONBLOCK,
999 s->backlog,
1000 s->bind_ipv6_only,
1001 s->bind_to_device,
1002 s->free_bind,
1003 s->transparent,
1004 s->directory_mode,
1005 s->socket_mode,
1006 label);
1007 if (r < 0)
83c60c9f
LP		 1008 goto rollback;
1009
175a3d25 1010 p->fd = r;
4fd5948e
LP		 1011 socket_apply_socket_options(s, p->fd);
1012
b0a3f2bc
LP		 1013 } else if (p->type == SOCKET_SPECIAL) {
1014
175a3d25
LP		 1015 r = special_address_create(
1016 p->path,
1017 &p->fd);
1018 if (r < 0)
b0a3f2bc
LP		 1019 goto rollback;
1020
b15bdda8 1021 } else if (p->type == SOCKET_FIFO) {
83c60c9f 1022
175a3d25
LP		 1023 r = fifo_address_create(
1024 p->path,
1025 s->directory_mode,
1026 s->socket_mode,
1027 &p->fd);
1028 if (r < 0)
83c60c9f 1029 goto rollback;
83c60c9f 1030
b15bdda8 1031 socket_apply_fifo_options(s, p->fd);
916abb21 1032 } else if (p->type == SOCKET_MQUEUE) {
83c60c9f 1033
175a3d25
LP		 1034 r = mq_address_create(
1035 p->path,
1036 s->socket_mode,
1037 s->mq_maxmsg,
1038 s->mq_msgsize,
1039 &p->fd);
1040 if (r < 0)
916abb21 1041 goto rollback;
b15bdda8
LP		 1042 } else
1043 assert_not_reached("Unknown port type");
034c6ed7
LP		 1044 }
1045
56cf987f 1046 label_free(label);
034c6ed7
LP		 1047 return 0;
1048
1049rollback:
1050 socket_close_fds(s);
56cf987f 1051 label_free(label);
034c6ed7
LP		 1052 return r;
1053}
1054
1055static void socket_unwatch_fds(Socket *s) {
1056 SocketPort *p;
9152c765 1057
034c6ed7
LP		 1058 assert(s);
1059
1060 LIST_FOREACH(port, p, s->ports) {
1061 if (p->fd < 0)
1062 continue;
1063
acbb0225 1064 unit_unwatch_fd(UNIT(s), &p->fd_watch);
83c60c9f 1065 }
034c6ed7
LP		 1066}
1067
1068static int socket_watch_fds(Socket *s) {
1069 SocketPort *p;
1070 int r;
1071
1072 assert(s);
83c60c9f 1073
034c6ed7
LP		 1074 LIST_FOREACH(port, p, s->ports) {
1075 if (p->fd < 0)
1076 continue;
1077
cabab516 1078 p->fd_watch.socket_accept =
4f2d528d 1079 s->accept &&
dd5ad9d4 1080 p->type == SOCKET_SOCKET &&
4f2d528d
LP		 1081 socket_address_can_accept(&p->address);
1082
f94ea366 1083 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
034c6ed7
LP		 1084 goto fail;
1085 }
83c60c9f 1086
542563ba 1087 return 0;
83c60c9f 1088
034c6ed7
LP		 1089fail:
1090 socket_unwatch_fds(s);
1091 return r;
1092}
1093
1094static void socket_set_state(Socket *s, SocketState state) {
1095 SocketState old_state;
1096 assert(s);
1097
1098 old_state = s->state;
1099 s->state = state;
1100
1101 if (state != SOCKET_START_PRE &&
1102 state != SOCKET_START_POST &&
1103 state != SOCKET_STOP_PRE &&
1104 state != SOCKET_STOP_PRE_SIGTERM &&
1105 state != SOCKET_STOP_PRE_SIGKILL &&
1106 state != SOCKET_STOP_POST &&
80876c20
LP		 1107 state != SOCKET_FINAL_SIGTERM &&
1108 state != SOCKET_FINAL_SIGKILL) {
acbb0225 1109 unit_unwatch_timer(UNIT(s), &s->timer_watch);
5e94833f 1110 socket_unwatch_control_pid(s);
034c6ed7 1111 s->control_command = NULL;
a16e1123 1112 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
e537352b 1113 }
034c6ed7 1114
a16e1123
LP		 1115 if (state != SOCKET_LISTENING)
1116 socket_unwatch_fds(s);
1117
034c6ed7
LP		 1118 if (state != SOCKET_START_POST &&
1119 state != SOCKET_LISTENING &&
1120 state != SOCKET_RUNNING &&
1121 state != SOCKET_STOP_PRE &&
1122 state != SOCKET_STOP_PRE_SIGTERM &&
1123 state != SOCKET_STOP_PRE_SIGKILL)
1124 socket_close_fds(s);
1125
e537352b 1126 if (state != old_state)
66870f90
ZJS		 1127 log_debug_unit(UNIT(s)->id,
1128 "%s changed %s -> %s", UNIT(s)->id,
1129 socket_state_to_string(old_state),
1130 socket_state_to_string(state));
acbb0225 1131
e2f3b44c 1132 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
034c6ed7
LP		 1133}
1134
a16e1123
LP		 1135static int socket_coldplug(Unit *u) {
1136 Socket *s = SOCKET(u);
1137 int r;
1138
1139 assert(s);
1140 assert(s->state == SOCKET_DEAD);
1141
1142 if (s->deserialized_state != s->state) {
1143
1144 if (s->deserialized_state == SOCKET_START_PRE ||
1145 s->deserialized_state == SOCKET_START_POST ||
1146 s->deserialized_state == SOCKET_STOP_PRE ||
1147 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1148 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1149 s->deserialized_state == SOCKET_STOP_POST ||
1150 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1151 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1152
1153 if (s->control_pid <= 0)
1154 return -EBADMSG;
1155
36697dc0
LP		 1156 r = unit_watch_pid(UNIT(s), s->control_pid);
1157 if (r < 0)
a16e1123
LP		 1158 return r;
1159
36697dc0
LP		 1160 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1161 if (r < 0)
a16e1123
LP		 1162 return r;
1163 }
1164
1165 if (s->deserialized_state == SOCKET_START_POST ||
1166 s->deserialized_state == SOCKET_LISTENING ||
1167 s->deserialized_state == SOCKET_RUNNING ||
1168 s->deserialized_state == SOCKET_STOP_PRE ||
1169 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1170 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1171 if ((r = socket_open_fds(s)) < 0)
1172 return r;
1173
1174 if (s->deserialized_state == SOCKET_LISTENING)
1175 if ((r = socket_watch_fds(s)) < 0)
1176 return r;
1177
1178 socket_set_state(s, s->deserialized_state);
1179 }
1180
1181 return 0;
1182}
1183
e537352b 1184static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
034c6ed7
LP		 1185 pid_t pid;
1186 int r;
9e2f7c11 1187 char **argv;
034c6ed7
LP		 1188
1189 assert(s);
1190 assert(c);
1191 assert(_pid);
1192
4ad49000
LP		 1193 unit_realize_cgroup(UNIT(s));
1194
36697dc0
LP		 1195 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1196 if (r < 0)
e537352b 1197 goto fail;
034c6ed7 1198
19f6d710
LP		 1199 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1200 if (r < 0)
9e2f7c11 1201 goto fail;
9e2f7c11
LP		 1202
1203 r = exec_spawn(c,
1204 argv,
1205 &s->exec_context,
1206 NULL, 0,
1124fe6f 1207 UNIT(s)->manager->environment,
9e2f7c11
LP		 1208 true,
1209 true,
1e3ad081 1210 true,
1124fe6f 1211 UNIT(s)->manager->confirm_spawn,
13b84ec7 1212 UNIT(s)->manager->cgroup_supported,
4ad49000 1213 UNIT(s)->cgroup_path,
62bca2c6 1214 UNIT(s)->id,
f2b68789 1215 NULL,
9e2f7c11
LP		 1216 &pid);
1217
1218 strv_free(argv);
1219 if (r < 0)
034c6ed7
LP		 1220 goto fail;
1221
87f0e418 1222 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
034c6ed7
LP		 1223 /* FIXME: we need to do something here */
1224 goto fail;
83c60c9f 1225
034c6ed7
LP		 1226 *_pid = pid;
1227
1228 return 0;
1229
1230fail:
e537352b 1231 unit_unwatch_timer(UNIT(s), &s->timer_watch);
83c60c9f
LP		 1232
1233 return r;
542563ba
LP		 1234}
1235
cfc4eb4c 1236static void socket_enter_dead(Socket *s, SocketResult f) {
034c6ed7
LP		 1237 assert(s);
1238
cfc4eb4c
LP		 1239 if (f != SOCKET_SUCCESS)
1240 s->result = f;
034c6ed7 1241
c17ec25e 1242 exec_context_tmp_dirs_done(&s->exec_context);
cfc4eb4c 1243 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
034c6ed7
LP		 1244}
1245
cfc4eb4c 1246static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
80876c20 1247
cfc4eb4c 1248static void socket_enter_stop_post(Socket *s, SocketResult f) {
034c6ed7
LP		 1249 int r;
1250 assert(s);
1251
cfc4eb4c
LP		 1252 if (f != SOCKET_SUCCESS)
1253 s->result = f;
034c6ed7 1254
5e94833f
LP		 1255 socket_unwatch_control_pid(s);
1256
a16e1123
LP		 1257 s->control_command_id = SOCKET_EXEC_STOP_POST;
1258
80876c20 1259 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
e537352b 1260 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
034c6ed7
LP		 1261 goto fail;
1262
80876c20
LP		 1263 socket_set_state(s, SOCKET_STOP_POST);
1264 } else
cfc4eb4c 1265 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
034c6ed7
LP		 1266
1267 return;
1268
1269fail:
66870f90
ZJS		 1270 log_warning_unit(UNIT(s)->id,
1271 "%s failed to run 'stop-post' task: %s",
1272 UNIT(s)->id, strerror(-r));
cfc4eb4c 1273 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
034c6ed7
LP		 1274}
1275
cfc4eb4c 1276static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
034c6ed7
LP		 1277 int r;
1278
1279 assert(s);
1280
cfc4eb4c
LP		 1281 if (f != SOCKET_SUCCESS)
1282 s->result = f;
034c6ed7 1283
cd2086fe
LP		 1284 r = unit_kill_context(
1285 UNIT(s),
1286 &s->kill_context,
1287 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1288 -1,
1289 s->control_pid,
1290 false);
1291 if (r < 0)
1292 goto fail;
034c6ed7 1293
cd2086fe 1294 if (r > 0) {
36697dc0
LP		 1295 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1296 if (r < 0)
80876c20 1297 goto fail;
d6ea93e3 1298
80876c20
LP		 1299 socket_set_state(s, state);
1300 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
cfc4eb4c 1301 socket_enter_stop_post(s, SOCKET_SUCCESS);
80876c20 1302 else
cfc4eb4c 1303 socket_enter_dead(s, SOCKET_SUCCESS);
034c6ed7
LP		 1304
1305 return;
1306
1307fail:
66870f90
ZJS		 1308 log_warning_unit(UNIT(s)->id,
1309 "%s failed to kill processes: %s",
1310 UNIT(s)->id, strerror(-r));
034c6ed7
LP		 1311
1312 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
cfc4eb4c 1313 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
034c6ed7 1314 else
cfc4eb4c 1315 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
034c6ed7
LP		 1316}
1317
cfc4eb4c 1318static void socket_enter_stop_pre(Socket *s, SocketResult f) {
034c6ed7
LP		 1319 int r;
1320 assert(s);
1321
cfc4eb4c
LP		 1322 if (f != SOCKET_SUCCESS)
1323 s->result = f;
034c6ed7 1324
5e94833f
LP		 1325 socket_unwatch_control_pid(s);
1326
a16e1123
LP		 1327 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1328
80876c20 1329 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
e537352b 1330 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
034c6ed7
LP		 1331 goto fail;
1332
80876c20
LP		 1333 socket_set_state(s, SOCKET_STOP_PRE);
1334 } else
cfc4eb4c 1335 socket_enter_stop_post(s, SOCKET_SUCCESS);
034c6ed7
LP		 1336
1337 return;
1338
1339fail:
66870f90
ZJS		 1340 log_warning_unit(UNIT(s)->id,
1341 "%s failed to run 'stop-pre' task: %s",
1342 UNIT(s)->id, strerror(-r));
cfc4eb4c 1343 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
034c6ed7
LP		 1344}
1345
e9af15c3
LP		 1346static void socket_enter_listening(Socket *s) {
1347 int r;
1348 assert(s);
1349
cfc4eb4c
LP		 1350 r = socket_watch_fds(s);
1351 if (r < 0) {
66870f90
ZJS		 1352 log_warning_unit(UNIT(s)->id,
1353 "%s failed to watch sockets: %s",
1354 UNIT(s)->id, strerror(-r));
e9af15c3
LP		 1355 goto fail;
1356 }
1357
1358 socket_set_state(s, SOCKET_LISTENING);
1359 return;
1360
1361fail:
cfc4eb4c 1362 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
e9af15c3
LP		 1363}
1364
034c6ed7
LP		 1365static void socket_enter_start_post(Socket *s) {
1366 int r;
1367 assert(s);
1368
cfc4eb4c
LP		 1369 r = socket_open_fds(s);
1370 if (r < 0) {
66870f90
ZJS		 1371 log_warning_unit(UNIT(s)->id,
1372 "%s failed to listen on sockets: %s",
1373 UNIT(s)->id, strerror(-r));
034c6ed7
LP		 1374 goto fail;
1375 }
1376
5e94833f
LP		 1377 socket_unwatch_control_pid(s);
1378
a16e1123
LP		 1379 s->control_command_id = SOCKET_EXEC_START_POST;
1380
80876c20 1381 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
cfc4eb4c
LP		 1382 r = socket_spawn(s, s->control_command, &s->control_pid);
1383 if (r < 0) {
66870f90
ZJS		 1384 log_warning_unit(UNIT(s)->id,
1385 "%s failed to run 'start-post' task: %s",
1386 UNIT(s)->id, strerror(-r));
034c6ed7
LP		 1387 goto fail;
1388 }
1389
80876c20
LP		 1390 socket_set_state(s, SOCKET_START_POST);
1391 } else
e9af15c3 1392 socket_enter_listening(s);
034c6ed7
LP		 1393
1394 return;
1395
1396fail:
cfc4eb4c 1397 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
034c6ed7
LP		 1398}
1399
1400static void socket_enter_start_pre(Socket *s) {
1401 int r;
1402 assert(s);
1403
5e94833f
LP		 1404 socket_unwatch_control_pid(s);
1405
a16e1123
LP		 1406 s->control_command_id = SOCKET_EXEC_START_PRE;
1407
80876c20 1408 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
e537352b 1409 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
034c6ed7
LP		 1410 goto fail;
1411
80876c20
LP		 1412 socket_set_state(s, SOCKET_START_PRE);
1413 } else
034c6ed7
LP		 1414 socket_enter_start_post(s);
1415
1416 return;
1417
1418fail:
66870f90
ZJS		 1419 log_warning_unit(UNIT(s)->id,
1420 "%s failed to run 'start-pre' task: %s",
1421 UNIT(s)->id, strerror(-r));
cfc4eb4c 1422 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
034c6ed7
LP		 1423}
1424
4f2d528d 1425static void socket_enter_running(Socket *s, int cfd) {
034c6ed7 1426 int r;
398ef8ba 1427 DBusError error;
034c6ed7
LP		 1428
1429 assert(s);
398ef8ba 1430 dbus_error_init(&error);
034c6ed7 1431
ba3e67a7
LP		 1432 /* We don't take connections anymore if we are supposed to
1433 * shut down anyway */
31afa0a4 1434 if (unit_stop_pending(UNIT(s))) {
66870f90
ZJS		 1435 log_debug_unit(UNIT(s)->id,
1436 "Suppressing connection request on %s since unit stop is scheduled.",
1437 UNIT(s)->id);
5d909e3e 1438
7c610628
LP		 1439 if (cfd >= 0)
1440 close_nointr_nofail(cfd);
1441 else {
1442 /* Flush all sockets by closing and reopening them */
1443 socket_close_fds(s);
1444
1a710b43
MS		 1445 r = socket_watch_fds(s);
1446 if (r < 0) {
66870f90
ZJS		 1447 log_warning_unit(UNIT(s)->id,
1448 "%s failed to watch sockets: %s",
1449 UNIT(s)->id, strerror(-r));
cfc4eb4c 1450 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
7c610628
LP		 1451 }
1452 }
1453
ba3e67a7
LP		 1454 return;
1455 }
1456
4f2d528d 1457 if (cfd < 0) {
57020a3a
LP		 1458 Iterator i;
1459 Unit *u;
f976f3f6 1460 bool pending = false;
f976f3f6
LP		 1461
1462 /* If there's already a start pending don't bother to
1463 * do anything */
1124fe6f 1464 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
31afa0a4 1465 if (unit_active_or_pending(u)) {
57020a3a
LP		 1466 pending = true;
1467 break;
1468 }
f976f3f6 1469
1a710b43
MS		 1470 if (!pending) {
1471 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1472 if (r < 0)
f976f3f6 1473 goto fail;
1a710b43 1474 }
4f2d528d
LP		 1475
1476 socket_set_state(s, SOCKET_RUNNING);
1477 } else {
b4f10a5e 1478 char *prefix, *instance = NULL, *name;
b15bdda8 1479 Service *service;
4f2d528d 1480
6cf6bbc2 1481 if (s->n_connections >= s->max_connections) {
66870f90
ZJS		 1482 log_warning_unit(UNIT(s)->id,
1483 "%s: Too many incoming connections (%u)",
1484 UNIT(s)->id, s->n_connections);
6cf6bbc2
LP		 1485 close_nointr_nofail(cfd);
1486 return;
1487 }
1488
1a710b43
MS		 1489 r = socket_instantiate_service(s);
1490 if (r < 0)
b15bdda8
LP		 1491 goto fail;
1492
1a710b43
MS		 1493 r = instance_from_socket(cfd, s->n_accepted, &instance);
1494 if (r < 0) {
1495 if (r != -ENOTCONN)
1496 goto fail;
1497
1498 /* ENOTCONN is legitimate if TCP RST was received.
1499 * This connection is over, but the socket unit lives on. */
1500 close_nointr_nofail(cfd);
1501 return;
1502 }
4f2d528d 1503
1a710b43
MS		 1504 prefix = unit_name_to_prefix(UNIT(s)->id);
1505 if (!prefix) {
4f2d528d
LP		 1506 free(instance);
1507 r = -ENOMEM;
1508 goto fail;
1509 }
1510
1511 name = unit_name_build(prefix, instance, ".service");
1512 free(prefix);
1513 free(instance);
1514
b6dbbe1c 1515 if (!name) {
4f2d528d 1516 r = -ENOMEM;
b6dbbe1c
LP		 1517 goto fail;
1518 }
4f2d528d 1519
1a710b43
MS		 1520 r = unit_add_name(UNIT_DEREF(s->service), name);
1521 if (r < 0) {
b15bdda8 1522 free(name);
4f2d528d 1523 goto fail;
b15bdda8
LP		 1524 }
1525
57020a3a
LP		 1526 service = SERVICE(UNIT_DEREF(s->service));
1527 unit_ref_unset(&s->service);
b15bdda8 1528 s->n_accepted ++;
4f2d528d 1529
1124fe6f 1530 UNIT(service)->no_gc = false;
6c073082 1531
b15bdda8
LP		 1532 unit_choose_id(UNIT(service), name);
1533 free(name);
1534
1a710b43
MS		 1535 r = service_set_socket_fd(service, cfd, s);
1536 if (r < 0)
4f2d528d
LP		 1537 goto fail;
1538
1539 cfd = -1;
6cf6bbc2
LP		 1540 s->n_connections ++;
1541
1a710b43
MS		 1542 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1543 if (r < 0)
4f2d528d 1544 goto fail;
c4e2ceae
LP		 1545
1546 /* Notify clients about changed counters */
1547 unit_add_to_dbus_queue(UNIT(s));
4f2d528d 1548 }
034c6ed7 1549
034c6ed7
LP		 1550 return;
1551
1552fail:
66870f90
ZJS		 1553 log_warning_unit(UNIT(s)->id,
1554 "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1555 UNIT(s)->id,
1556 cfd >= 0 ? "template" : "non-template",
1557 bus_error(&error, r));
60089004 1558 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
4f2d528d
LP		 1559
1560 if (cfd >= 0)
1561 close_nointr_nofail(cfd);
398ef8ba
LP		 1562
1563 dbus_error_free(&error);
034c6ed7
LP		 1564}
1565
cfc4eb4c 1566static void socket_run_next(Socket *s) {
034c6ed7
LP		 1567 int r;
1568
1569 assert(s);
1570 assert(s->control_command);
1571 assert(s->control_command->command_next);
1572
5e94833f
LP		 1573 socket_unwatch_control_pid(s);
1574
034c6ed7
LP		 1575 s->control_command = s->control_command->command_next;
1576
e537352b 1577 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
034c6ed7
LP		 1578 goto fail;
1579
1580 return;
1581
1582fail:
66870f90
ZJS		 1583 log_warning_unit(UNIT(s)->id,
1584 "%s failed to run next task: %s",
1585 UNIT(s)->id, strerror(-r));
80876c20
LP		 1586
1587 if (s->state == SOCKET_START_POST)
cfc4eb4c 1588 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
034c6ed7 1589 else if (s->state == SOCKET_STOP_POST)
cfc4eb4c 1590 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
034c6ed7 1591 else
cfc4eb4c 1592 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
034c6ed7
LP		 1593}
1594
87f0e418
LP		 1595static int socket_start(Unit *u) {
1596 Socket *s = SOCKET(u);
83c60c9f
LP		 1597
1598 assert(s);
1599
034c6ed7
LP		 1600 /* We cannot fulfill this request right now, try again later
1601 * please! */
1602 if (s->state == SOCKET_STOP_PRE ||
1603 s->state == SOCKET_STOP_PRE_SIGKILL ||
1604 s->state == SOCKET_STOP_PRE_SIGTERM ||
1605 s->state == SOCKET_STOP_POST ||
80876c20
LP		 1606 s->state == SOCKET_FINAL_SIGTERM ||
1607 s->state == SOCKET_FINAL_SIGKILL)
034c6ed7
LP		 1608 return -EAGAIN;
1609
83c60c9f
LP		 1610 if (s->state == SOCKET_START_PRE ||
1611 s->state == SOCKET_START_POST)
034c6ed7 1612 return 0;
83c60c9f 1613
034c6ed7 1614 /* Cannot run this without the service being around */
9444b1f2 1615 if (UNIT_ISSET(s->service)) {
57020a3a
LP		 1616 Service *service;
1617
1618 service = SERVICE(UNIT_DEREF(s->service));
1619
1124fe6f 1620 if (UNIT(service)->load_state != UNIT_LOADED) {
d7607eac 1621 log_error_unit(u->id,
66870f90
ZJS		 1622 "Socket service %s not loaded, refusing.",
1623 UNIT(service)->id);
4f2d528d 1624 return -ENOENT;
4ac9236f 1625 }
4f2d528d 1626
35b8ca3a 1627 /* If the service is already active we cannot start the
4f2d528d 1628 * socket */
57020a3a
LP		 1629 if (service->state != SERVICE_DEAD &&
1630 service->state != SERVICE_FAILED &&
1631 service->state != SERVICE_AUTO_RESTART) {
d7607eac 1632 log_error_unit(u->id,
66870f90
ZJS		 1633 "Socket service %s already active, refusing.",
1634 UNIT(service)->id);
4f2d528d 1635 return -EBUSY;
4ac9236f 1636 }
7b4bf06b
LP		 1637
1638#ifdef HAVE_SYSV_COMPAT
1b64d026 1639 if (service->is_sysv) {
d7607eac 1640 log_error_unit(u->id,
66870f90 1641 "Using SysV services for socket activation is not supported. Refusing.");
7b4bf06b
LP		 1642 return -ENOENT;
1643 }
1644#endif
4f2d528d 1645 }
e537352b 1646
fdf20a31 1647 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
83c60c9f 1648
cfc4eb4c 1649 s->result = SOCKET_SUCCESS;
034c6ed7
LP		 1650 socket_enter_start_pre(s);
1651 return 0;
1652}
83c60c9f 1653
87f0e418
LP		 1654static int socket_stop(Unit *u) {
1655 Socket *s = SOCKET(u);
034c6ed7
LP		 1656
1657 assert(s);
1658
e537352b
LP		 1659 /* Already on it */
1660 if (s->state == SOCKET_STOP_PRE ||
1661 s->state == SOCKET_STOP_PRE_SIGTERM ||
1662 s->state == SOCKET_STOP_PRE_SIGKILL ||
1663 s->state == SOCKET_STOP_POST ||
80876c20 1664 s->state == SOCKET_FINAL_SIGTERM ||
3f6c78dc 1665 s->state == SOCKET_FINAL_SIGKILL)
e537352b
LP		 1666 return 0;
1667
3f6c78dc
LP		 1668 /* If there's already something running we go directly into
1669 * kill mode. */
1670 if (s->state == SOCKET_START_PRE ||
1671 s->state == SOCKET_START_POST) {
cfc4eb4c 1672 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
3f6c78dc
LP		 1673 return -EAGAIN;
1674 }
1675
034c6ed7 1676 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
83c60c9f 1677
cfc4eb4c 1678 socket_enter_stop_pre(s, SOCKET_SUCCESS);
542563ba
LP		 1679 return 0;
1680}
1681
a16e1123
LP		 1682static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1683 Socket *s = SOCKET(u);
1684 SocketPort *p;
1685 int r;
1686
1687 assert(u);
1688 assert(f);
1689 assert(fds);
1690
1691 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
cfc4eb4c 1692 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
a16e1123
LP		 1693 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1694
1695 if (s->control_pid > 0)
5925dd3c 1696 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
a16e1123
LP		 1697
1698 if (s->control_command_id >= 0)
1699 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1700
1701 LIST_FOREACH(port, p, s->ports) {
1702 int copy;
1703
1704 if (p->fd < 0)
1705 continue;
1706
1707 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1708 return copy;
1709
1710 if (p->type == SOCKET_SOCKET) {
1711 char *t;
1712
ee092817
LP		 1713 r = socket_address_print(&p->address, &t);
1714 if (r < 0)
a16e1123
LP		 1715 return r;
1716
7a22745a
LP		 1717 if (socket_address_family(&p->address) == AF_NETLINK)
1718 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1719 else
1720 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
a16e1123 1721 free(t);
b0a3f2bc
LP		 1722 } else if (p->type == SOCKET_SPECIAL)
1723 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
ee092817
LP		 1724 else if (p->type == SOCKET_MQUEUE)
1725 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
b0a3f2bc 1726 else {
a16e1123
LP		 1727 assert(p->type == SOCKET_FIFO);
1728 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1729 }
1730 }
1731
c17ec25e
MS		 1732 exec_context_serialize(&s->exec_context, UNIT(s), f);
1733
a16e1123
LP		 1734 return 0;
1735}
1736
1737static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1738 Socket *s = SOCKET(u);
a16e1123
LP		 1739
1740 assert(u);
1741 assert(key);
1742 assert(value);
1743 assert(fds);
1744
1745 if (streq(key, "state")) {
1746 SocketState state;
1747
ee092817
LP		 1748 state = socket_state_from_string(value);
1749 if (state < 0)
66870f90
ZJS		 1750 log_debug_unit(u->id,
1751 "Failed to parse state value %s", value);
a16e1123
LP		 1752 else
1753 s->deserialized_state = state;
cfc4eb4c
LP		 1754 } else if (streq(key, "result")) {
1755 SocketResult f;
a16e1123 1756
cfc4eb4c
LP		 1757 f = socket_result_from_string(value);
1758 if (f < 0)
66870f90
ZJS		 1759 log_debug_unit(u->id,
1760 "Failed to parse result value %s", value);
cfc4eb4c
LP		 1761 else if (f != SOCKET_SUCCESS)
1762 s->result = f;
a16e1123
LP		 1763
1764 } else if (streq(key, "n-accepted")) {
1765 unsigned k;
1766
e364ad06 1767 if (safe_atou(value, &k) < 0)
66870f90
ZJS		 1768 log_debug_unit(u->id,
1769 "Failed to parse n-accepted value %s", value);
a16e1123
LP		 1770 else
1771 s->n_accepted += k;
1772 } else if (streq(key, "control-pid")) {
5925dd3c 1773 pid_t pid;
a16e1123 1774
e364ad06 1775 if (parse_pid(value, &pid) < 0)
66870f90
ZJS		 1776 log_debug_unit(u->id,
1777 "Failed to parse control-pid value %s", value);
a16e1123 1778 else
5925dd3c 1779 s->control_pid = pid;
a16e1123
LP		 1780 } else if (streq(key, "control-command")) {
1781 SocketExecCommand id;
1782
66870f90
ZJS		 1783 id = socket_exec_command_from_string(value);
1784 if (id < 0)
1785 log_debug_unit(u->id,
1786 "Failed to parse exec-command value %s", value);
a16e1123
LP		 1787 else {
1788 s->control_command_id = id;
1789 s->control_command = s->exec_command[id];
1790 }
1791 } else if (streq(key, "fifo")) {
1792 int fd, skip = 0;
1793 SocketPort *p;
1794
1795 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
66870f90
ZJS		 1796 log_debug_unit(u->id,
1797 "Failed to parse fifo value %s", value);
a16e1123
LP		 1798 else {
1799
1800 LIST_FOREACH(port, p, s->ports)
b0a3f2bc
LP		 1801 if (p->type == SOCKET_FIFO &&
1802 streq_ptr(p->path, value+skip))
1803 break;
1804
1805 if (p) {
1806 if (p->fd >= 0)
1807 close_nointr_nofail(p->fd);
1808 p->fd = fdset_remove(fds, fd);
1809 }
1810 }
1811
1812 } else if (streq(key, "special")) {
1813 int fd, skip = 0;
1814 SocketPort *p;
1815
1816 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
66870f90
ZJS		 1817 log_debug_unit(u->id,
1818 "Failed to parse special value %s", value);
b0a3f2bc
LP		 1819 else {
1820
1821 LIST_FOREACH(port, p, s->ports)
1822 if (p->type == SOCKET_SPECIAL &&
1823 streq_ptr(p->path, value+skip))
a16e1123
LP		 1824 break;
1825
1826 if (p) {
1827 if (p->fd >= 0)
1828 close_nointr_nofail(p->fd);
1829 p->fd = fdset_remove(fds, fd);
1830 }
1831 }
1832
ee092817
LP		 1833 } else if (streq(key, "mqueue")) {
1834 int fd, skip = 0;
1835 SocketPort *p;
1836
1837 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
66870f90
ZJS		 1838 log_debug_unit(u->id,
1839 "Failed to parse mqueue value %s", value);
ee092817
LP		 1840 else {
1841
1842 LIST_FOREACH(port, p, s->ports)
1843 if (p->type == SOCKET_MQUEUE &&
1844 streq_ptr(p->path, value+skip))
1845 break;
1846
1847 if (p) {
1848 if (p->fd >= 0)
1849 close_nointr_nofail(p->fd);
1850 p->fd = fdset_remove(fds, fd);
1851 }
1852 }
1853
a16e1123 1854 } else if (streq(key, "socket")) {
27ca8d7a 1855 int fd, type, skip = 0;
a16e1123
LP		 1856 SocketPort *p;
1857
27ca8d7a 1858 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
66870f90
ZJS		 1859 log_debug_unit(u->id,
1860 "Failed to parse socket value %s", value);
a16e1123
LP		 1861 else {
1862
1863 LIST_FOREACH(port, p, s->ports)
27ca8d7a 1864 if (socket_address_is(&p->address, value+skip, type))
a16e1123
LP		 1865 break;
1866
1867 if (p) {
1868 if (p->fd >= 0)
1869 close_nointr_nofail(p->fd);
1870 p->fd = fdset_remove(fds, fd);
1871 }
1872 }
1873
7a22745a
LP		 1874 } else if (streq(key, "netlink")) {
1875 int fd, skip = 0;
1876 SocketPort *p;
1877
1878 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
66870f90
ZJS		 1879 log_debug_unit(u->id,
1880 "Failed to parse socket value %s", value);
7a22745a
LP		 1881 else {
1882
1883 LIST_FOREACH(port, p, s->ports)
1884 if (socket_address_is_netlink(&p->address, value+skip))
1885 break;
1886
1887 if (p) {
1888 if (p->fd >= 0)
1889 close_nointr_nofail(p->fd);
1890 p->fd = fdset_remove(fds, fd);
1891 }
1892 }
c17ec25e
MS		 1893 } else if (streq(key, "tmp-dir")) {
1894 char *t;
1895
1896 t = strdup(value);
1897 if (!t)
1898 return log_oom();
1899
1900 s->exec_context.tmp_dir = t;
1901 } else if (streq(key, "var-tmp-dir")) {
1902 char *t;
1903
1904 t = strdup(value);
1905 if (!t)
1906 return log_oom();
7a22745a 1907
c17ec25e 1908 s->exec_context.var_tmp_dir = t;
a16e1123 1909 } else
66870f90
ZJS		 1910 log_debug_unit(UNIT(s)->id,
1911 "Unknown serialization key '%s'", key);
a16e1123
LP		 1912
1913 return 0;
1914}
1915
01e10de3
LP		 1916static int socket_distribute_fds(Unit *u, FDSet *fds) {
1917 Socket *s = SOCKET(u);
1918 SocketPort *p;
1919
1920 assert(u);
1921
1922 LIST_FOREACH(port, p, s->ports) {
1923 Iterator i;
1924 int fd;
1925
1926 if (p->type != SOCKET_SOCKET)
1927 continue;
1928
1929 if (p->fd >= 0)
1930 continue;
1931
1932 FDSET_FOREACH(fd, fds, i) {
1933 if (socket_address_matches_fd(&p->address, fd)) {
1934 p->fd = fdset_remove(fds, fd);
1935 s->deserialized_state = SOCKET_LISTENING;
1936 break;
1937 }
1938 }
1939 }
1940
1941 return 0;
1942}
1943
44a6b1b6 1944_pure_ static UnitActiveState socket_active_state(Unit *u) {
87f0e418 1945 assert(u);
5cb5a6ff 1946
acbb0225 1947 return state_translation_table[SOCKET(u)->state];
5cb5a6ff
LP		 1948}
1949
44a6b1b6 1950_pure_ static const char *socket_sub_state_to_string(Unit *u) {
10a94420
LP		 1951 assert(u);
1952
a16e1123 1953 return socket_state_to_string(SOCKET(u)->state);
10a94420
LP		 1954}
1955
67419600
OS		 1956const char* socket_port_type_to_string(SocketPort *p) {
1957
1958 assert(p);
1959
1960 switch (p->type) {
1961 case SOCKET_SOCKET:
1962 switch (p->address.type) {
1963 case SOCK_STREAM: return "Stream";
1964 case SOCK_DGRAM: return "Datagram";
1965 case SOCK_SEQPACKET: return "SequentialPacket";
1966 case SOCK_RAW:
1967 if (socket_address_family(&p->address) == AF_NETLINK)
1968 return "Netlink";
1969 default: return "Invalid";
1970 }
1971 case SOCKET_SPECIAL: return "Special";
1972 case SOCKET_MQUEUE: return "MessageQueue";
1973 case SOCKET_FIFO: return "FIFO";
1974 default: return NULL;
1975 }
1976}
1977
44a6b1b6 1978_pure_ static bool socket_check_gc(Unit *u) {
6cf6bbc2
LP		 1979 Socket *s = SOCKET(u);
1980
1981 assert(u);
1982
1983 return s->n_connections > 0;
1984}
1985
acbb0225 1986static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
87f0e418 1987 Socket *s = SOCKET(u);
4f2d528d 1988 int cfd = -1;
9152c765 1989
034c6ed7 1990 assert(s);
8d567588 1991 assert(fd >= 0);
9152c765 1992
871d7de4
LP		 1993 if (s->state != SOCKET_LISTENING)
1994 return;
1995
66870f90 1996 log_debug_unit(u->id, "Incoming traffic on %s", u->id);
9152c765 1997
4f2d528d 1998 if (events != EPOLLIN) {
641e01dc
LP		 1999
2000 if (events & EPOLLHUP)
66870f90
ZJS		 2001 log_error_unit(u->id,
2002 "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
2003 u->id);
641e01dc 2004 else
66870f90
ZJS		 2005 log_error_unit(u->id,
2006 "%s: Got unexpected poll event (0x%x) on socket.",
2007 u->id, events);
641e01dc 2008
8d567588 2009 goto fail;
4f2d528d
LP		 2010 }
2011
cabab516 2012 if (w->socket_accept) {
4f2d528d
LP		 2013 for (;;) {
2014
b14eda96
LP		 2015 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2016 if (cfd < 0) {
4f2d528d
LP		 2017
2018 if (errno == EINTR)
2019 continue;
2020
66870f90
ZJS		 2021 log_error_unit(u->id,
2022 "Failed to accept socket: %m");
8d567588 2023 goto fail;
4f2d528d
LP		 2024 }
2025
2026 break;
2027 }
4fd5948e
LP		 2028
2029 socket_apply_socket_options(s, cfd);
4f2d528d 2030 }
9152c765 2031
4f2d528d 2032 socket_enter_running(s, cfd);
8d567588
LP		 2033 return;
2034
2035fail:
cfc4eb4c 2036 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
9152c765
LP		 2037}
2038
87f0e418
LP		 2039static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2040 Socket *s = SOCKET(u);
cfc4eb4c 2041 SocketResult f;
5cb5a6ff
LP		 2042
2043 assert(s);
034c6ed7 2044 assert(pid >= 0);
5cb5a6ff 2045
8c47c732
LP		 2046 if (pid != s->control_pid)
2047 return;
542563ba 2048
034c6ed7
LP		 2049 s->control_pid = 0;
2050
96342de6 2051 if (is_clean_exit(code, status, NULL))
cfc4eb4c
LP		 2052 f = SOCKET_SUCCESS;
2053 else if (code == CLD_EXITED)
2054 f = SOCKET_FAILURE_EXIT_CODE;
2055 else if (code == CLD_KILLED)
2056 f = SOCKET_FAILURE_SIGNAL;
2057 else if (code == CLD_DUMPED)
2058 f = SOCKET_FAILURE_CORE_DUMP;
2059 else
2060 assert_not_reached("Unknown code");
8c47c732 2061
b708e7ce 2062 if (s->control_command) {
6ea832a2 2063 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
a16e1123 2064
b708e7ce 2065 if (s->control_command->ignore)
cfc4eb4c 2066 f = SOCKET_SUCCESS;
b708e7ce
LP		 2067 }
2068
66870f90
ZJS		 2069 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2070 u->id,
2071 "%s control process exited, code=%s status=%i",
2072 u->id, sigchld_code_to_string(code), status);
034c6ed7 2073
cfc4eb4c
LP		 2074 if (f != SOCKET_SUCCESS)
2075 s->result = f;
2076
2077 if (s->control_command &&
2078 s->control_command->command_next &&
2079 f == SOCKET_SUCCESS) {
2080
66870f90
ZJS		 2081 log_debug_unit(u->id,
2082 "%s running next command for state %s",
2083 u->id, socket_state_to_string(s->state));
cfc4eb4c 2084 socket_run_next(s);
acbb0225 2085 } else {
a16e1123
LP		 2086 s->control_command = NULL;
2087 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2088
034c6ed7
LP		 2089 /* No further commands for this step, so let's figure
2090 * out what to do next */
5cb5a6ff 2091
66870f90
ZJS		 2092 log_debug_unit(u->id,
2093 "%s got final SIGCHLD for state %s",
2094 u->id, socket_state_to_string(s->state));
acbb0225 2095
034c6ed7
LP		 2096 switch (s->state) {
2097
2098 case SOCKET_START_PRE:
cfc4eb4c 2099 if (f == SOCKET_SUCCESS)
acbb0225 2100 socket_enter_start_post(s);
034c6ed7 2101 else
cfc4eb4c 2102 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
034c6ed7
LP		 2103 break;
2104
2105 case SOCKET_START_POST:
cfc4eb4c 2106 if (f == SOCKET_SUCCESS)
e9af15c3 2107 socket_enter_listening(s);
034c6ed7 2108 else
cfc4eb4c 2109 socket_enter_stop_pre(s, f);
034c6ed7
LP		 2110 break;
2111
2112 case SOCKET_STOP_PRE:
2113 case SOCKET_STOP_PRE_SIGTERM:
2114 case SOCKET_STOP_PRE_SIGKILL:
cfc4eb4c 2115 socket_enter_stop_post(s, f);
034c6ed7
LP		 2116 break;
2117
2118 case SOCKET_STOP_POST:
80876c20
LP		 2119 case SOCKET_FINAL_SIGTERM:
2120 case SOCKET_FINAL_SIGKILL:
cfc4eb4c 2121 socket_enter_dead(s, f);
034c6ed7
LP		 2122 break;
2123
2124 default:
2125 assert_not_reached("Uh, control process died at wrong time.");
2126 }
2127 }
c4e2ceae
LP		 2128
2129 /* Notify clients about changed exit status */
2130 unit_add_to_dbus_queue(u);
034c6ed7 2131}
5cb5a6ff 2132
acbb0225 2133static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
87f0e418 2134 Socket *s = SOCKET(u);
5cb5a6ff 2135
034c6ed7
LP		 2136 assert(s);
2137 assert(elapsed == 1);
acbb0225 2138 assert(w == &s->timer_watch);
034c6ed7
LP		 2139
2140 switch (s->state) {
2141
2142 case SOCKET_START_PRE:
66870f90
ZJS		 2143 log_warning_unit(u->id,
2144 "%s starting timed out. Terminating.", u->id);
cfc4eb4c 2145 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
da19d5c1 2146 break;
80876c20 2147
034c6ed7 2148 case SOCKET_START_POST:
66870f90
ZJS		 2149 log_warning_unit(u->id,
2150 "%s starting timed out. Stopping.", u->id);
cfc4eb4c 2151 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
034c6ed7
LP		 2152 break;
2153
2154 case SOCKET_STOP_PRE:
66870f90
ZJS		 2155 log_warning_unit(u->id,
2156 "%s stopping timed out. Terminating.", u->id);
cfc4eb4c 2157 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
034c6ed7
LP		 2158 break;
2159
2160 case SOCKET_STOP_PRE_SIGTERM:
4819ff03 2161 if (s->kill_context.send_sigkill) {
66870f90
ZJS		 2162 log_warning_unit(u->id,
2163 "%s stopping timed out. Killing.", u->id);
cfc4eb4c 2164 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
ba035df2 2165 } else {
66870f90
ZJS		 2166 log_warning_unit(u->id,
2167 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2168 u->id);
cfc4eb4c 2169 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
ba035df2 2170 }
034c6ed7
LP		 2171 break;
2172
2173 case SOCKET_STOP_PRE_SIGKILL:
66870f90
ZJS		 2174 log_warning_unit(u->id,
2175 "%s still around after SIGKILL. Ignoring.", u->id);
cfc4eb4c 2176 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
034c6ed7
LP		 2177 break;
2178
2179 case SOCKET_STOP_POST:
66870f90
ZJS		 2180 log_warning_unit(u->id,
2181 "%s stopping timed out (2). Terminating.", u->id);
cfc4eb4c 2182 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
034c6ed7
LP		 2183 break;
2184
80876c20 2185 case SOCKET_FINAL_SIGTERM:
4819ff03 2186 if (s->kill_context.send_sigkill) {
66870f90
ZJS		 2187 log_warning_unit(u->id,
2188 "%s stopping timed out (2). Killing.", u->id);
cfc4eb4c 2189 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
ba035df2 2190 } else {
66870f90
ZJS		 2191 log_warning_unit(u->id,
2192 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2193 u->id);
cfc4eb4c 2194 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
ba035df2 2195 }
034c6ed7
LP		 2196 break;
2197
80876c20 2198 case SOCKET_FINAL_SIGKILL:
66870f90
ZJS		 2199 log_warning_unit(u->id,
2200 "%s still around after SIGKILL (2). Entering failed mode.",
2201 u->id);
cfc4eb4c 2202 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
034c6ed7
LP		 2203 break;
2204
2205 default:
2206 assert_not_reached("Timeout at wrong time.");
2207 }
5cb5a6ff
LP		 2208}
2209
44d8db9e
LP		 2210int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2211 int *rfds;
2212 unsigned rn_fds, k;
2213 SocketPort *p;
2214
2215 assert(s);
2216 assert(fds);
2217 assert(n_fds);
2218
2219 /* Called from the service code for requesting our fds */
2220
2221 rn_fds = 0;
2222 LIST_FOREACH(port, p, s->ports)
2223 if (p->fd >= 0)
2224 rn_fds++;
2225
de3756ab
LP		 2226 if (rn_fds <= 0) {
2227 *fds = NULL;
2228 *n_fds = 0;
2229 return 0;
2230 }
2231
e364ad06 2232 if (!(rfds = new(int, rn_fds)))
44d8db9e
LP		 2233 return -ENOMEM;
2234
2235 k = 0;
2236 LIST_FOREACH(port, p, s->ports)
2237 if (p->fd >= 0)
2238 rfds[k++] = p->fd;
2239
2240 assert(k == rn_fds);
2241
2242 *fds = rfds;
2243 *n_fds = rn_fds;
2244
2245 return 0;
2246}
2247
d137a488 2248static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
ceee3d82
LP		 2249 assert(s);
2250
6cf6bbc2
LP		 2251 /* The service is dead. Dang!
2252 *
2253 * This is strictly for one-instance-for-all-connections
2254 * services. */
ceee3d82
LP		 2255
2256 if (s->state == SOCKET_RUNNING) {
66870f90
ZJS		 2257 log_debug_unit(UNIT(s)->id,
2258 "%s got notified about service death (failed permanently: %s)",
2259 UNIT(s)->id, yes_no(failed_permanent));
6bda96a0
LP		 2260 if (failed_permanent)
2261 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
c2f34808
MS		 2262 else
2263 socket_enter_listening(s);
ceee3d82
LP		 2264 }
2265}
2266
6cf6bbc2
LP		 2267void socket_connection_unref(Socket *s) {
2268 assert(s);
2269
2270 /* The service is dead. Yay!
2271 *
35b8ca3a 2272 * This is strictly for one-instance-per-connection
6cf6bbc2
LP		 2273 * services. */
2274
2275 assert(s->n_connections > 0);
2276 s->n_connections--;
2277
66870f90
ZJS		 2278 log_debug_unit(UNIT(s)->id,
2279 "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
6cf6bbc2
LP		 2280}
2281
fdf20a31 2282static void socket_reset_failed(Unit *u) {
5632e374
LP		 2283 Socket *s = SOCKET(u);
2284
2285 assert(s);
2286
fdf20a31 2287 if (s->state == SOCKET_FAILED)
5632e374
LP		 2288 socket_set_state(s, SOCKET_DEAD);
2289
cfc4eb4c 2290 s->result = SOCKET_SUCCESS;
5632e374
LP		 2291}
2292
d137a488
UTL		 2293static void socket_trigger_notify(Unit *u, Unit *other) {
2294 Socket *s = SOCKET(u);
2295 Service *se = SERVICE(other);
2296
2297 assert(u);
2298 assert(other);
2299
2300 /* Don't propagate state changes from the service if we are
2301 already down or accepting connections */
2302 if ((s->state != SOCKET_RUNNING &&
2303 s->state != SOCKET_LISTENING) ||
2304 s->accept)
2305 return;
2306
2307 if (other->load_state != UNIT_LOADED ||
2308 other->type != UNIT_SERVICE)
2309 return;
2310
2311 if (se->state == SERVICE_FAILED)
2312 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2313
2314 if (se->state == SERVICE_DEAD ||
2315 se->state == SERVICE_STOP ||
2316 se->state == SERVICE_STOP_SIGTERM ||
2317 se->state == SERVICE_STOP_SIGKILL ||
2318 se->state == SERVICE_STOP_POST ||
2319 se->state == SERVICE_FINAL_SIGTERM ||
2320 se->state == SERVICE_FINAL_SIGKILL ||
2321 se->state == SERVICE_AUTO_RESTART)
2322 socket_notify_service_dead(s, false);
2323
2324 if (se->state == SERVICE_RUNNING)
2325 socket_set_state(s, SOCKET_RUNNING);
2326}
2327
c74f17d9 2328static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
814cc562 2329 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
8a0867d6
LP		 2330}
2331
a16e1123
LP		 2332static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2333 [SOCKET_DEAD] = "dead",
2334 [SOCKET_START_PRE] = "start-pre",
2335 [SOCKET_START_POST] = "start-post",
2336 [SOCKET_LISTENING] = "listening",
2337 [SOCKET_RUNNING] = "running",
2338 [SOCKET_STOP_PRE] = "stop-pre",
2339 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2340 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2341 [SOCKET_STOP_POST] = "stop-post",
2342 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2343 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
fdf20a31 2344 [SOCKET_FAILED] = "failed"
a16e1123
LP		 2345};
2346
2347DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2348
2349static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2350 [SOCKET_EXEC_START_PRE] = "StartPre",
2351 [SOCKET_EXEC_START_POST] = "StartPost",
2352 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2353 [SOCKET_EXEC_STOP_POST] = "StopPost"
2354};
2355
2356DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2357
cfc4eb4c
LP		 2358static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2359 [SOCKET_SUCCESS] = "success",
2360 [SOCKET_FAILURE_RESOURCES] = "resources",
2361 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2362 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2363 [SOCKET_FAILURE_SIGNAL] = "signal",
c2f34808 2364 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
6bda96a0 2365 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
cfc4eb4c
LP		 2366};
2367
2368DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2369
87f0e418 2370const UnitVTable socket_vtable = {
7d17cfbc 2371 .object_size = sizeof(Socket),
3ef63c31 2372
f975e971
LP		 2373 .sections =
2374 "Unit\0"
2375 "Socket\0"
2376 "Install\0",
5cb5a6ff 2377
4ad49000 2378 .private_section = "Socket",
71645aca 2379 .exec_context_offset = offsetof(Socket, exec_context),
4ad49000 2380 .cgroup_context_offset = offsetof(Socket, cgroup_context),
71645aca 2381
034c6ed7
LP		 2382 .init = socket_init,
2383 .done = socket_done,
a16e1123
LP		 2384 .load = socket_load,
2385
8a0867d6
LP		 2386 .kill = socket_kill,
2387
a16e1123 2388 .coldplug = socket_coldplug,
034c6ed7 2389
5cb5a6ff
LP		 2390 .dump = socket_dump,
2391
542563ba
LP		 2392 .start = socket_start,
2393 .stop = socket_stop,
5cb5a6ff 2394
a16e1123
LP		 2395 .serialize = socket_serialize,
2396 .deserialize_item = socket_deserialize_item,
01e10de3 2397 .distribute_fds = socket_distribute_fds,
a16e1123 2398
5cb5a6ff 2399 .active_state = socket_active_state,
10a94420 2400 .sub_state_to_string = socket_sub_state_to_string,
5cb5a6ff 2401
6cf6bbc2
LP		 2402 .check_gc = socket_check_gc,
2403
9152c765 2404 .fd_event = socket_fd_event,
034c6ed7 2405 .sigchld_event = socket_sigchld_event,
4139c1b2
LP		 2406 .timer_event = socket_timer_event,
2407
d137a488
UTL		 2408 .trigger_notify = socket_trigger_notify,
2409
fdf20a31 2410 .reset_failed = socket_reset_failed,
5632e374 2411
c4e2ceae
LP		 2412 .bus_interface = "org.freedesktop.systemd1.Socket",
2413 .bus_message_handler = bus_socket_message_handler,
c6918296 2414 .bus_invalidating_properties = bus_socket_invalidating_properties,
74c964d3
LP		 2415 .bus_set_property = bus_socket_set_property,
2416 .bus_commit_properties = bus_socket_commit_properties,
c6918296
MS		 2417
2418 .status_message_formats = {
2419 /*.starting_stopping = {
2420 [0] = "Starting socket %s...",
2421 [1] = "Stopping socket %s...",
2422 },*/
2423 .finished_start_job = {
2424 [JOB_DONE] = "Listening on %s.",
2425 [JOB_FAILED] = "Failed to listen on %s.",
2426 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2427 [JOB_TIMEOUT] = "Timed out starting %s.",
2428 },
2429 .finished_stop_job = {
2430 [JOB_DONE] = "Closed %s.",
2431 [JOB_FAILED] = "Failed stopping %s.",
2432 [JOB_TIMEOUT] = "Timed out stopping %s.",
2433 },
2434 },
5cb5a6ff 2435};
Unnamed repository; edit this file 'description' to name the repository.