1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include <sys/types.h>
27 #include <sys/epoll.h>
29 #include <arpa/inet.h>
34 #include "netinet/tcp.h"
36 #include "load-dropin.h"
37 #include "load-fragment.h"
40 #include "path-util.h"
41 #include "unit-name.h"
42 #include "dbus-socket.h"
45 #include "bus-errors.h"
47 #include "exit-status.h"
50 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
51 [SOCKET_DEAD] = UNIT_INACTIVE,
52 [SOCKET_START_PRE] = UNIT_ACTIVATING,
53 [SOCKET_START_POST] = UNIT_ACTIVATING,
54 [SOCKET_LISTENING] = UNIT_ACTIVE,
55 [SOCKET_RUNNING] = UNIT_ACTIVE,
56 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
57 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
58 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
59 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
60 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
61 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
62 [SOCKET_FAILED] = UNIT_FAILED
65 static void socket_init(Unit *u) {
66 Socket *s = SOCKET(u);
69 assert(u->load_state == UNIT_STUB);
71 s->backlog = SOMAXCONN;
72 s->timeout_usec = DEFAULT_TIMEOUT_USEC;
73 s->directory_mode = 0755;
74 s->socket_mode = 0666;
76 s->max_connections = 64;
83 exec_context_init(&s->exec_context);
84 s->exec_context.std_output = u->manager->default_std_output;
85 s->exec_context.std_error = u->manager->default_std_error;
86 kill_context_init(&s->kill_context);
88 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
91 static void socket_unwatch_control_pid(Socket *s) {
94 if (s->control_pid <= 0)
97 unit_unwatch_pid(UNIT(s), s->control_pid);
101 static void socket_done(Unit *u) {
102 Socket *s = SOCKET(u);
107 while ((p = s->ports)) {
108 LIST_REMOVE(SocketPort, port, s->ports, p);
111 unit_unwatch_fd(UNIT(s), &p->fd_watch);
112 close_nointr_nofail(p->fd);
119 exec_context_done(&s->exec_context);
120 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
121 s->control_command = NULL;
123 socket_unwatch_control_pid(s);
125 unit_ref_unset(&s->service);
127 free(s->tcp_congestion);
128 s->tcp_congestion = NULL;
130 free(s->bind_to_device);
131 s->bind_to_device = NULL;
133 unit_unwatch_timer(u, &s->timer_watch);
136 static int socket_instantiate_service(Socket *s) {
143 /* This fills in s->service if it isn't filled in yet. For
144 * Accept=yes sockets we create the next connection service
145 * here. For Accept=no this is mostly a NOP since the service
146 * is figured out at load time anyway. */
148 if (UNIT_DEREF(s->service))
153 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
156 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
162 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
168 #ifdef HAVE_SYSV_COMPAT
169 if (SERVICE(u)->is_sysv) {
170 log_error("Using SysV services for socket activation is not supported. Refusing.");
176 unit_ref_set(&s->service, u);
178 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
181 static bool have_non_accept_socket(Socket *s) {
189 LIST_FOREACH(port, p, s->ports) {
191 if (p->type != SOCKET_SOCKET)
194 if (!socket_address_can_accept(&p->address))
201 static int socket_verify(Socket *s) {
204 if (UNIT(s)->load_state != UNIT_LOADED)
208 log_error("%s lacks Listen setting. Refusing.", UNIT(s)->id);
212 if (s->accept && have_non_accept_socket(s)) {
213 log_error("%s configured for accepting sockets, but sockets are non-accepting. Refusing.", UNIT(s)->id);
217 if (s->accept && s->max_connections <= 0) {
218 log_error("%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
222 if (s->accept && UNIT_DEREF(s->service)) {
223 log_error("Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
227 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
228 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
235 static bool socket_needs_mount(Socket *s, const char *prefix) {
240 LIST_FOREACH(port, p, s->ports) {
242 if (p->type == SOCKET_SOCKET) {
243 if (socket_address_needs_mount(&p->address, prefix))
245 } else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL) {
246 if (path_startswith(p->path, prefix))
254 int socket_add_one_mount_link(Socket *s, Mount *m) {
260 if (UNIT(s)->load_state != UNIT_LOADED ||
261 UNIT(m)->load_state != UNIT_LOADED)
264 if (!socket_needs_mount(s, m->where))
267 if ((r = unit_add_two_dependencies(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true)) < 0)
273 static int socket_add_mount_links(Socket *s) {
279 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_MOUNT])
280 if ((r = socket_add_one_mount_link(s, MOUNT(other))) < 0)
286 static int socket_add_device_link(Socket *s) {
292 if (!s->bind_to_device)
295 if (asprintf(&t, "/sys/subsystem/net/devices/%s", s->bind_to_device) < 0)
298 r = unit_add_node_link(UNIT(s), t, false);
304 static int socket_add_default_dependencies(Socket *s) {
308 if (UNIT(s)->manager->running_as == MANAGER_SYSTEM) {
309 if ((r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true)) < 0)
312 if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true)) < 0)
316 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
319 static bool socket_has_exec(Socket *s) {
323 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
324 if (s->exec_command[i])
330 static int socket_load(Unit *u) {
331 Socket *s = SOCKET(u);
335 assert(u->load_state == UNIT_STUB);
337 if ((r = unit_load_fragment_and_dropin(u)) < 0)
340 /* This is a new unit? Then let's add in some extras */
341 if (u->load_state == UNIT_LOADED) {
343 if (have_non_accept_socket(s)) {
345 if (!UNIT_DEREF(s->service)) {
348 r = unit_load_related_unit(u, ".service", &x);
352 unit_ref_set(&s->service, x);
355 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
360 if ((r = socket_add_mount_links(s)) < 0)
363 if ((r = socket_add_device_link(s)) < 0)
366 if (socket_has_exec(s))
367 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
370 if ((r = unit_add_default_cgroups(u)) < 0)
373 if (UNIT(s)->default_dependencies)
374 if ((r = socket_add_default_dependencies(s)) < 0)
377 r = unit_exec_context_defaults(u, &s->exec_context);
382 return socket_verify(s);
385 static const char* listen_lookup(int family, int type) {
387 if (family == AF_NETLINK)
388 return "ListenNetlink";
390 if (type == SOCK_STREAM)
391 return "ListenStream";
392 else if (type == SOCK_DGRAM)
393 return "ListenDatagram";
394 else if (type == SOCK_SEQPACKET)
395 return "ListenSequentialPacket";
397 assert_not_reached("Unknown socket type");
401 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
404 Socket *s = SOCKET(u);
412 p2 = strappend(prefix, "\t");
413 prefix2 = p2 ? p2 : prefix;
416 "%sSocket State: %s\n"
418 "%sBindIPv6Only: %s\n"
420 "%sSocketMode: %04o\n"
421 "%sDirectoryMode: %04o\n"
424 "%sTransparent: %s\n"
426 "%sPassCredentials: %s\n"
427 "%sPassSecurity: %s\n"
428 "%sTCPCongestion: %s\n",
429 prefix, socket_state_to_string(s->state),
430 prefix, socket_result_to_string(s->result),
431 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
433 prefix, s->socket_mode,
434 prefix, s->directory_mode,
435 prefix, yes_no(s->keep_alive),
436 prefix, yes_no(s->free_bind),
437 prefix, yes_no(s->transparent),
438 prefix, yes_no(s->broadcast),
439 prefix, yes_no(s->pass_cred),
440 prefix, yes_no(s->pass_sec),
441 prefix, strna(s->tcp_congestion));
443 if (s->control_pid > 0)
445 "%sControl PID: %lu\n",
446 prefix, (unsigned long) s->control_pid);
448 if (s->bind_to_device)
450 "%sBindToDevice: %s\n",
451 prefix, s->bind_to_device);
456 "%sNConnections: %u\n"
457 "%sMaxConnections: %u\n",
458 prefix, s->n_accepted,
459 prefix, s->n_connections,
460 prefix, s->max_connections);
462 if (s->priority >= 0)
465 prefix, s->priority);
467 if (s->receive_buffer > 0)
469 "%sReceiveBuffer: %zu\n",
470 prefix, s->receive_buffer);
472 if (s->send_buffer > 0)
474 "%sSendBuffer: %zu\n",
475 prefix, s->send_buffer);
487 if (s->pipe_size > 0)
490 prefix, s->pipe_size);
497 if (s->mq_maxmsg > 0)
499 "%sMessageQueueMaxMessages: %li\n",
500 prefix, s->mq_maxmsg);
502 if (s->mq_msgsize > 0)
504 "%sMessageQueueMessageSize: %li\n",
505 prefix, s->mq_msgsize);
507 LIST_FOREACH(port, p, s->ports) {
509 if (p->type == SOCKET_SOCKET) {
514 if ((r = socket_address_print(&p->address, &k)) < 0)
519 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
521 } else if (p->type == SOCKET_SPECIAL)
522 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
523 else if (p->type == SOCKET_MQUEUE)
524 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
526 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
529 exec_context_dump(&s->exec_context, f, prefix);
530 kill_context_dump(&s->kill_context, f, prefix);
532 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
533 if (!s->exec_command[c])
536 fprintf(f, "%s-> %s:\n",
537 prefix, socket_exec_command_to_string(c));
539 exec_command_dump_list(s->exec_command[c], f, prefix2);
545 static int instance_from_socket(int fd, unsigned nr, char **instance) {
550 struct sockaddr_un un;
551 struct sockaddr_in in;
552 struct sockaddr_in6 in6;
553 struct sockaddr_storage storage;
560 if (getsockname(fd, &local.sa, &l) < 0)
564 if (getpeername(fd, &remote.sa, &l) < 0)
567 switch (local.sa.sa_family) {
571 a = ntohl(local.in.sin_addr.s_addr),
572 b = ntohl(remote.in.sin_addr.s_addr);
575 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
577 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
578 ntohs(local.in.sin_port),
579 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
580 ntohs(remote.in.sin_port)) < 0)
587 static const unsigned char ipv4_prefix[] = {
588 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
591 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
592 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
594 *a = local.in6.sin6_addr.s6_addr+12,
595 *b = remote.in6.sin6_addr.s6_addr+12;
598 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
600 a[0], a[1], a[2], a[3],
601 ntohs(local.in6.sin6_port),
602 b[0], b[1], b[2], b[3],
603 ntohs(remote.in6.sin6_port)) < 0)
606 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
611 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
612 ntohs(local.in6.sin6_port),
613 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
614 ntohs(remote.in6.sin6_port)) < 0)
625 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
631 (unsigned long) ucred.pid,
632 (unsigned long) ucred.uid) < 0)
639 assert_not_reached("Unhandled socket type.");
646 static void socket_close_fds(Socket *s) {
651 LIST_FOREACH(port, p, s->ports) {
655 unit_unwatch_fd(UNIT(s), &p->fd_watch);
656 close_nointr_nofail(p->fd);
658 /* One little note: we should never delete any sockets
659 * in the file system here! After all some other
660 * process we spawned might still have a reference of
661 * this fd and wants to continue to use it. Therefore
662 * we delete sockets in the file system before we
663 * create a new one, not after we stopped using
670 static void socket_apply_socket_options(Socket *s, int fd) {
675 int b = s->keep_alive;
676 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
677 log_warning("SO_KEEPALIVE failed: %m");
682 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
683 log_warning("SO_BROADCAST failed: %m");
688 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
689 log_warning("SO_PASSCRED failed: %m");
694 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
695 log_warning("SO_PASSSEC failed: %m");
698 if (s->priority >= 0)
699 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
700 log_warning("SO_PRIORITY failed: %m");
702 if (s->receive_buffer > 0) {
703 int value = (int) s->receive_buffer;
705 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
707 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
708 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
709 log_warning("SO_RCVBUF failed: %m");
712 if (s->send_buffer > 0) {
713 int value = (int) s->send_buffer;
714 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
715 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
716 log_warning("SO_SNDBUF failed: %m");
720 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
721 log_warning("SO_MARK failed: %m");
724 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
725 log_warning("IP_TOS failed: %m");
727 if (s->ip_ttl >= 0) {
730 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
732 if (socket_ipv6_is_supported())
733 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
736 errno = EAFNOSUPPORT;
740 log_warning("IP_TTL/IPV6_UNICAST_HOPS failed: %m");
743 if (s->tcp_congestion)
744 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
745 log_warning("TCP_CONGESTION failed: %m");
748 static void socket_apply_fifo_options(Socket *s, int fd) {
752 if (s->pipe_size > 0)
753 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
754 log_warning("F_SETPIPE_SZ: %m");
757 static int fifo_address_create(
759 mode_t directory_mode,
770 mkdir_parents_label(path, directory_mode);
772 r = label_context_set(path, S_IFIFO);
776 /* Enforce the right access mode for the fifo */
777 old_mask = umask(~ socket_mode);
779 /* Include the original umask in our mask */
780 umask(~socket_mode | old_mask);
782 r = mkfifo(path, socket_mode);
785 if (r < 0 && errno != EEXIST) {
790 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
795 label_context_clear();
797 if (fstat(fd, &st) < 0) {
802 if (!S_ISFIFO(st.st_mode) ||
803 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
804 st.st_uid != getuid() ||
805 st.st_gid != getgid()) {
815 label_context_clear();
818 close_nointr_nofail(fd);
823 static int special_address_create(
833 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
838 if (fstat(fd, &st) < 0) {
843 /* Check whether this is a /proc, /sys or /dev file or char device */
844 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
854 close_nointr_nofail(fd);
859 static int mq_address_create(
869 struct mq_attr _attr, *attr = NULL;
874 if (maxmsg > 0 && msgsize > 0) {
876 _attr.mq_flags = O_NONBLOCK;
877 _attr.mq_maxmsg = maxmsg;
878 _attr.mq_msgsize = msgsize;
882 /* Enforce the right access mode for the mq */
883 old_mask = umask(~ mq_mode);
885 /* Include the original umask in our mask */
886 umask(~mq_mode | old_mask);
888 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
896 if (fstat(fd, &st) < 0) {
901 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
902 st.st_uid != getuid() ||
903 st.st_gid != getgid()) {
914 close_nointr_nofail(fd);
919 static int socket_open_fds(Socket *s) {
923 bool know_label = false;
927 LIST_FOREACH(port, p, s->ports) {
932 if (p->type == SOCKET_SOCKET) {
936 if ((r = socket_instantiate_service(s)) < 0)
939 if (UNIT_DEREF(s->service) &&
940 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
941 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
952 if ((r = socket_address_listen(
965 socket_apply_socket_options(s, p->fd);
967 } else if (p->type == SOCKET_SPECIAL) {
969 if ((r = special_address_create(
974 } else if (p->type == SOCKET_FIFO) {
976 if ((r = fifo_address_create(
983 socket_apply_fifo_options(s, p->fd);
984 } else if (p->type == SOCKET_MQUEUE) {
986 if ((r = mq_address_create(
994 assert_not_reached("Unknown port type");
1001 socket_close_fds(s);
1006 static void socket_unwatch_fds(Socket *s) {
1011 LIST_FOREACH(port, p, s->ports) {
1015 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1019 static int socket_watch_fds(Socket *s) {
1025 LIST_FOREACH(port, p, s->ports) {
1029 p->fd_watch.socket_accept =
1031 p->type == SOCKET_SOCKET &&
1032 socket_address_can_accept(&p->address);
1034 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1041 socket_unwatch_fds(s);
1045 static void socket_set_state(Socket *s, SocketState state) {
1046 SocketState old_state;
1049 old_state = s->state;
1052 if (state != SOCKET_START_PRE &&
1053 state != SOCKET_START_POST &&
1054 state != SOCKET_STOP_PRE &&
1055 state != SOCKET_STOP_PRE_SIGTERM &&
1056 state != SOCKET_STOP_PRE_SIGKILL &&
1057 state != SOCKET_STOP_POST &&
1058 state != SOCKET_FINAL_SIGTERM &&
1059 state != SOCKET_FINAL_SIGKILL) {
1060 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1061 socket_unwatch_control_pid(s);
1062 s->control_command = NULL;
1063 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1066 if (state != SOCKET_LISTENING)
1067 socket_unwatch_fds(s);
1069 if (state != SOCKET_START_POST &&
1070 state != SOCKET_LISTENING &&
1071 state != SOCKET_RUNNING &&
1072 state != SOCKET_STOP_PRE &&
1073 state != SOCKET_STOP_PRE_SIGTERM &&
1074 state != SOCKET_STOP_PRE_SIGKILL)
1075 socket_close_fds(s);
1077 if (state != old_state)
1078 log_debug("%s changed %s -> %s",
1080 socket_state_to_string(old_state),
1081 socket_state_to_string(state));
1083 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1086 static int socket_coldplug(Unit *u) {
1087 Socket *s = SOCKET(u);
1091 assert(s->state == SOCKET_DEAD);
1093 if (s->deserialized_state != s->state) {
1095 if (s->deserialized_state == SOCKET_START_PRE ||
1096 s->deserialized_state == SOCKET_START_POST ||
1097 s->deserialized_state == SOCKET_STOP_PRE ||
1098 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1099 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1100 s->deserialized_state == SOCKET_STOP_POST ||
1101 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1102 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1104 if (s->control_pid <= 0)
1107 if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
1110 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1114 if (s->deserialized_state == SOCKET_START_POST ||
1115 s->deserialized_state == SOCKET_LISTENING ||
1116 s->deserialized_state == SOCKET_RUNNING ||
1117 s->deserialized_state == SOCKET_STOP_PRE ||
1118 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1119 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1120 if ((r = socket_open_fds(s)) < 0)
1123 if (s->deserialized_state == SOCKET_LISTENING)
1124 if ((r = socket_watch_fds(s)) < 0)
1127 socket_set_state(s, s->deserialized_state);
1133 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1142 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1145 if (!(argv = unit_full_printf_strv(UNIT(s), c->argv))) {
1154 UNIT(s)->manager->environment,
1158 UNIT(s)->manager->confirm_spawn,
1159 UNIT(s)->cgroup_bondings,
1160 UNIT(s)->cgroup_attributes,
1170 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1171 /* FIXME: we need to do something here */
1179 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1184 static void socket_enter_dead(Socket *s, SocketResult f) {
1187 if (f != SOCKET_SUCCESS)
1190 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1193 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1195 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1199 if (f != SOCKET_SUCCESS)
1202 socket_unwatch_control_pid(s);
1204 s->control_command_id = SOCKET_EXEC_STOP_POST;
1206 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1207 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1210 socket_set_state(s, SOCKET_STOP_POST);
1212 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1217 log_warning("%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
1218 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1221 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1223 Set *pid_set = NULL;
1224 bool wait_for_exit = false;
1228 if (f != SOCKET_SUCCESS)
1231 if (s->kill_context.kill_mode != KILL_NONE) {
1232 int sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_FINAL_SIGTERM) ? s->kill_context.kill_signal : SIGKILL;
1234 if (s->control_pid > 0) {
1235 if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
1237 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
1239 wait_for_exit = true;
1242 if (s->kill_context.kill_mode == KILL_CONTROL_GROUP) {
1244 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
1249 /* Exclude the control pid from being killed via the cgroup */
1250 if (s->control_pid > 0)
1251 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
1254 r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
1256 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
1257 log_warning("Failed to kill control group: %s", strerror(-r));
1259 wait_for_exit = true;
1266 if (wait_for_exit) {
1267 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1270 socket_set_state(s, state);
1271 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1272 socket_enter_stop_post(s, SOCKET_SUCCESS);
1274 socket_enter_dead(s, SOCKET_SUCCESS);
1279 log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1281 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1282 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1284 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1290 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1294 if (f != SOCKET_SUCCESS)
1297 socket_unwatch_control_pid(s);
1299 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1301 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1302 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1305 socket_set_state(s, SOCKET_STOP_PRE);
1307 socket_enter_stop_post(s, SOCKET_SUCCESS);
1312 log_warning("%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1313 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1316 static void socket_enter_listening(Socket *s) {
1320 r = socket_watch_fds(s);
1322 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1326 socket_set_state(s, SOCKET_LISTENING);
1330 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1333 static void socket_enter_start_post(Socket *s) {
1337 r = socket_open_fds(s);
1339 log_warning("%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1343 socket_unwatch_control_pid(s);
1345 s->control_command_id = SOCKET_EXEC_START_POST;
1347 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1348 r = socket_spawn(s, s->control_command, &s->control_pid);
1350 log_warning("%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1354 socket_set_state(s, SOCKET_START_POST);
1356 socket_enter_listening(s);
1361 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1364 static void socket_enter_start_pre(Socket *s) {
1368 socket_unwatch_control_pid(s);
1370 s->control_command_id = SOCKET_EXEC_START_PRE;
1372 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1373 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1376 socket_set_state(s, SOCKET_START_PRE);
1378 socket_enter_start_post(s);
1383 log_warning("%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1384 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1387 static void socket_enter_running(Socket *s, int cfd) {
1392 dbus_error_init(&error);
1394 /* We don't take connections anymore if we are supposed to
1395 * shut down anyway */
1396 if (unit_pending_inactive(UNIT(s))) {
1397 log_debug("Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1400 close_nointr_nofail(cfd);
1402 /* Flush all sockets by closing and reopening them */
1403 socket_close_fds(s);
1405 r = socket_watch_fds(s);
1407 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1408 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1418 bool pending = false;
1420 /* If there's already a start pending don't bother to
1422 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1423 if (unit_pending_active(u)) {
1429 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1434 socket_set_state(s, SOCKET_RUNNING);
1436 char *prefix, *instance = NULL, *name;
1439 if (s->n_connections >= s->max_connections) {
1440 log_warning("Too many incoming connections (%u)", s->n_connections);
1441 close_nointr_nofail(cfd);
1445 r = socket_instantiate_service(s);
1449 r = instance_from_socket(cfd, s->n_accepted, &instance);
1454 /* ENOTCONN is legitimate if TCP RST was received.
1455 * This connection is over, but the socket unit lives on. */
1456 close_nointr_nofail(cfd);
1460 prefix = unit_name_to_prefix(UNIT(s)->id);
1467 name = unit_name_build(prefix, instance, ".service");
1476 r = unit_add_name(UNIT_DEREF(s->service), name);
1482 service = SERVICE(UNIT_DEREF(s->service));
1483 unit_ref_unset(&s->service);
1486 UNIT(service)->no_gc = false;
1488 unit_choose_id(UNIT(service), name);
1491 r = service_set_socket_fd(service, cfd, s);
1496 s->n_connections ++;
1498 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1502 /* Notify clients about changed counters */
1503 unit_add_to_dbus_queue(UNIT(s));
1509 log_warning("%s failed to queue socket startup job: %s", UNIT(s)->id, bus_error(&error, r));
1510 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1513 close_nointr_nofail(cfd);
1515 dbus_error_free(&error);
1518 static void socket_run_next(Socket *s) {
1522 assert(s->control_command);
1523 assert(s->control_command->command_next);
1525 socket_unwatch_control_pid(s);
1527 s->control_command = s->control_command->command_next;
1529 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1535 log_warning("%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1537 if (s->state == SOCKET_START_POST)
1538 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1539 else if (s->state == SOCKET_STOP_POST)
1540 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1542 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1545 static int socket_start(Unit *u) {
1546 Socket *s = SOCKET(u);
1550 /* We cannot fulfill this request right now, try again later
1552 if (s->state == SOCKET_STOP_PRE ||
1553 s->state == SOCKET_STOP_PRE_SIGKILL ||
1554 s->state == SOCKET_STOP_PRE_SIGTERM ||
1555 s->state == SOCKET_STOP_POST ||
1556 s->state == SOCKET_FINAL_SIGTERM ||
1557 s->state == SOCKET_FINAL_SIGKILL)
1560 if (s->state == SOCKET_START_PRE ||
1561 s->state == SOCKET_START_POST)
1564 /* Cannot run this without the service being around */
1565 if (UNIT_DEREF(s->service)) {
1568 service = SERVICE(UNIT_DEREF(s->service));
1570 if (UNIT(service)->load_state != UNIT_LOADED) {
1571 log_error("Socket service %s not loaded, refusing.", UNIT(service)->id);
1575 /* If the service is already active we cannot start the
1577 if (service->state != SERVICE_DEAD &&
1578 service->state != SERVICE_FAILED &&
1579 service->state != SERVICE_AUTO_RESTART) {
1580 log_error("Socket service %s already active, refusing.", UNIT(service)->id);
1584 #ifdef HAVE_SYSV_COMPAT
1585 if (service->is_sysv) {
1586 log_error("Using SysV services for socket activation is not supported. Refusing.");
1592 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1594 s->result = SOCKET_SUCCESS;
1595 socket_enter_start_pre(s);
1599 static int socket_stop(Unit *u) {
1600 Socket *s = SOCKET(u);
1605 if (s->state == SOCKET_STOP_PRE ||
1606 s->state == SOCKET_STOP_PRE_SIGTERM ||
1607 s->state == SOCKET_STOP_PRE_SIGKILL ||
1608 s->state == SOCKET_STOP_POST ||
1609 s->state == SOCKET_FINAL_SIGTERM ||
1610 s->state == SOCKET_FINAL_SIGKILL)
1613 /* If there's already something running we go directly into
1615 if (s->state == SOCKET_START_PRE ||
1616 s->state == SOCKET_START_POST) {
1617 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1621 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1623 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1627 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1628 Socket *s = SOCKET(u);
1636 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1637 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1638 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1640 if (s->control_pid > 0)
1641 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1643 if (s->control_command_id >= 0)
1644 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1646 LIST_FOREACH(port, p, s->ports) {
1652 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1655 if (p->type == SOCKET_SOCKET) {
1658 if ((r = socket_address_print(&p->address, &t)) < 0)
1661 if (socket_address_family(&p->address) == AF_NETLINK)
1662 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1664 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1666 } else if (p->type == SOCKET_SPECIAL)
1667 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1669 assert(p->type == SOCKET_FIFO);
1670 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1677 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1678 Socket *s = SOCKET(u);
1685 if (streq(key, "state")) {
1688 if ((state = socket_state_from_string(value)) < 0)
1689 log_debug("Failed to parse state value %s", value);
1691 s->deserialized_state = state;
1692 } else if (streq(key, "result")) {
1695 f = socket_result_from_string(value);
1697 log_debug("Failed to parse result value %s", value);
1698 else if (f != SOCKET_SUCCESS)
1701 } else if (streq(key, "n-accepted")) {
1704 if (safe_atou(value, &k) < 0)
1705 log_debug("Failed to parse n-accepted value %s", value);
1708 } else if (streq(key, "control-pid")) {
1711 if (parse_pid(value, &pid) < 0)
1712 log_debug("Failed to parse control-pid value %s", value);
1714 s->control_pid = pid;
1715 } else if (streq(key, "control-command")) {
1716 SocketExecCommand id;
1718 if ((id = socket_exec_command_from_string(value)) < 0)
1719 log_debug("Failed to parse exec-command value %s", value);
1721 s->control_command_id = id;
1722 s->control_command = s->exec_command[id];
1724 } else if (streq(key, "fifo")) {
1728 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1729 log_debug("Failed to parse fifo value %s", value);
1732 LIST_FOREACH(port, p, s->ports)
1733 if (p->type == SOCKET_FIFO &&
1734 streq_ptr(p->path, value+skip))
1739 close_nointr_nofail(p->fd);
1740 p->fd = fdset_remove(fds, fd);
1744 } else if (streq(key, "special")) {
1748 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1749 log_debug("Failed to parse special value %s", value);
1752 LIST_FOREACH(port, p, s->ports)
1753 if (p->type == SOCKET_SPECIAL &&
1754 streq_ptr(p->path, value+skip))
1759 close_nointr_nofail(p->fd);
1760 p->fd = fdset_remove(fds, fd);
1764 } else if (streq(key, "socket")) {
1765 int fd, type, skip = 0;
1768 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1769 log_debug("Failed to parse socket value %s", value);
1772 LIST_FOREACH(port, p, s->ports)
1773 if (socket_address_is(&p->address, value+skip, type))
1778 close_nointr_nofail(p->fd);
1779 p->fd = fdset_remove(fds, fd);
1783 } else if (streq(key, "netlink")) {
1787 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1788 log_debug("Failed to parse socket value %s", value);
1791 LIST_FOREACH(port, p, s->ports)
1792 if (socket_address_is_netlink(&p->address, value+skip))
1797 close_nointr_nofail(p->fd);
1798 p->fd = fdset_remove(fds, fd);
1803 log_debug("Unknown serialization key '%s'", key);
1808 static UnitActiveState socket_active_state(Unit *u) {
1811 return state_translation_table[SOCKET(u)->state];
1814 static const char *socket_sub_state_to_string(Unit *u) {
1817 return socket_state_to_string(SOCKET(u)->state);
1820 static bool socket_check_gc(Unit *u) {
1821 Socket *s = SOCKET(u);
1825 return s->n_connections > 0;
1828 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1829 Socket *s = SOCKET(u);
1835 if (s->state != SOCKET_LISTENING)
1838 log_debug("Incoming traffic on %s", u->id);
1840 if (events != EPOLLIN) {
1842 if (events & EPOLLHUP)
1843 log_error("%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.", u->id);
1845 log_error("%s: Got unexpected poll event (0x%x) on socket.", u->id, events);
1850 if (w->socket_accept) {
1853 if ((cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK)) < 0) {
1858 log_error("Failed to accept socket: %m");
1865 socket_apply_socket_options(s, cfd);
1868 socket_enter_running(s, cfd);
1872 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1875 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1876 Socket *s = SOCKET(u);
1882 if (pid != s->control_pid)
1887 if (is_clean_exit(code, status, NULL))
1889 else if (code == CLD_EXITED)
1890 f = SOCKET_FAILURE_EXIT_CODE;
1891 else if (code == CLD_KILLED)
1892 f = SOCKET_FAILURE_SIGNAL;
1893 else if (code == CLD_DUMPED)
1894 f = SOCKET_FAILURE_CORE_DUMP;
1896 assert_not_reached("Unknown code");
1898 if (s->control_command) {
1899 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
1901 if (s->control_command->ignore)
1905 log_full(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1906 "%s control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1908 if (f != SOCKET_SUCCESS)
1911 if (s->control_command &&
1912 s->control_command->command_next &&
1913 f == SOCKET_SUCCESS) {
1915 log_debug("%s running next command for state %s", u->id, socket_state_to_string(s->state));
1918 s->control_command = NULL;
1919 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1921 /* No further commands for this step, so let's figure
1922 * out what to do next */
1924 log_debug("%s got final SIGCHLD for state %s", u->id, socket_state_to_string(s->state));
1928 case SOCKET_START_PRE:
1929 if (f == SOCKET_SUCCESS)
1930 socket_enter_start_post(s);
1932 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
1935 case SOCKET_START_POST:
1936 if (f == SOCKET_SUCCESS)
1937 socket_enter_listening(s);
1939 socket_enter_stop_pre(s, f);
1942 case SOCKET_STOP_PRE:
1943 case SOCKET_STOP_PRE_SIGTERM:
1944 case SOCKET_STOP_PRE_SIGKILL:
1945 socket_enter_stop_post(s, f);
1948 case SOCKET_STOP_POST:
1949 case SOCKET_FINAL_SIGTERM:
1950 case SOCKET_FINAL_SIGKILL:
1951 socket_enter_dead(s, f);
1955 assert_not_reached("Uh, control process died at wrong time.");
1959 /* Notify clients about changed exit status */
1960 unit_add_to_dbus_queue(u);
1963 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1964 Socket *s = SOCKET(u);
1967 assert(elapsed == 1);
1968 assert(w == &s->timer_watch);
1972 case SOCKET_START_PRE:
1973 log_warning("%s starting timed out. Terminating.", u->id);
1974 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1977 case SOCKET_START_POST:
1978 log_warning("%s starting timed out. Stopping.", u->id);
1979 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
1982 case SOCKET_STOP_PRE:
1983 log_warning("%s stopping timed out. Terminating.", u->id);
1984 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1987 case SOCKET_STOP_PRE_SIGTERM:
1988 if (s->kill_context.send_sigkill) {
1989 log_warning("%s stopping timed out. Killing.", u->id);
1990 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
1992 log_warning("%s stopping timed out. Skipping SIGKILL. Ignoring.", u->id);
1993 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
1997 case SOCKET_STOP_PRE_SIGKILL:
1998 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
1999 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2002 case SOCKET_STOP_POST:
2003 log_warning("%s stopping timed out (2). Terminating.", u->id);
2004 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2007 case SOCKET_FINAL_SIGTERM:
2008 if (s->kill_context.send_sigkill) {
2009 log_warning("%s stopping timed out (2). Killing.", u->id);
2010 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2012 log_warning("%s stopping timed out (2). Skipping SIGKILL. Ignoring.", u->id);
2013 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2017 case SOCKET_FINAL_SIGKILL:
2018 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
2019 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2023 assert_not_reached("Timeout at wrong time.");
2027 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2036 /* Called from the service code for requesting our fds */
2039 LIST_FOREACH(port, p, s->ports)
2049 if (!(rfds = new(int, rn_fds)))
2053 LIST_FOREACH(port, p, s->ports)
2057 assert(k == rn_fds);
2065 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2068 /* The service is dead. Dang!
2070 * This is strictly for one-instance-for-all-connections
2073 if (s->state == SOCKET_RUNNING) {
2074 log_debug("%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2075 if (failed_permanent)
2076 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2078 socket_enter_listening(s);
2082 void socket_connection_unref(Socket *s) {
2085 /* The service is dead. Yay!
2087 * This is strictly for one-instance-per-connection
2090 assert(s->n_connections > 0);
2093 log_debug("%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2096 static void socket_reset_failed(Unit *u) {
2097 Socket *s = SOCKET(u);
2101 if (s->state == SOCKET_FAILED)
2102 socket_set_state(s, SOCKET_DEAD);
2104 s->result = SOCKET_SUCCESS;
2107 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2108 Socket *s = SOCKET(u);
2110 Set *pid_set = NULL;
2114 if (who == KILL_MAIN) {
2115 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Socket units have no main processes");
2119 if (s->control_pid <= 0 && who == KILL_CONTROL) {
2120 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2124 if (who == KILL_CONTROL || who == KILL_ALL)
2125 if (s->control_pid > 0)
2126 if (kill(s->control_pid, signo) < 0)
2129 if (who == KILL_ALL) {
2132 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2136 /* Exclude the control pid from being killed via the cgroup */
2137 if (s->control_pid > 0) {
2138 q = set_put(pid_set, LONG_TO_PTR(s->control_pid));
2145 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
2146 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2157 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2158 [SOCKET_DEAD] = "dead",
2159 [SOCKET_START_PRE] = "start-pre",
2160 [SOCKET_START_POST] = "start-post",
2161 [SOCKET_LISTENING] = "listening",
2162 [SOCKET_RUNNING] = "running",
2163 [SOCKET_STOP_PRE] = "stop-pre",
2164 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2165 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2166 [SOCKET_STOP_POST] = "stop-post",
2167 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2168 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2169 [SOCKET_FAILED] = "failed"
2172 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2174 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2175 [SOCKET_EXEC_START_PRE] = "StartPre",
2176 [SOCKET_EXEC_START_POST] = "StartPost",
2177 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2178 [SOCKET_EXEC_STOP_POST] = "StopPost"
2181 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2183 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2184 [SOCKET_SUCCESS] = "success",
2185 [SOCKET_FAILURE_RESOURCES] = "resources",
2186 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2187 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2188 [SOCKET_FAILURE_SIGNAL] = "signal",
2189 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2190 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2193 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2195 const UnitVTable socket_vtable = {
2196 .object_size = sizeof(Socket),
2202 .init = socket_init,
2203 .done = socket_done,
2204 .load = socket_load,
2206 .kill = socket_kill,
2208 .coldplug = socket_coldplug,
2210 .dump = socket_dump,
2212 .start = socket_start,
2213 .stop = socket_stop,
2215 .serialize = socket_serialize,
2216 .deserialize_item = socket_deserialize_item,
2218 .active_state = socket_active_state,
2219 .sub_state_to_string = socket_sub_state_to_string,
2221 .check_gc = socket_check_gc,
2223 .fd_event = socket_fd_event,
2224 .sigchld_event = socket_sigchld_event,
2225 .timer_event = socket_timer_event,
2227 .reset_failed = socket_reset_failed,
2229 .bus_interface = "org.freedesktop.systemd1.Socket",
2230 .bus_message_handler = bus_socket_message_handler,
2231 .bus_invalidating_properties = bus_socket_invalidating_properties,
2233 .status_message_formats = {
2234 /*.starting_stopping = {
2235 [0] = "Starting socket %s...",
2236 [1] = "Stopping socket %s...",
2238 .finished_start_job = {
2239 [JOB_DONE] = "Listening on %s.",
2240 [JOB_FAILED] = "Failed to listen on %s.",
2241 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2242 [JOB_TIMEOUT] = "Timed out starting %s.",
2244 .finished_stop_job = {
2245 [JOB_DONE] = "Closed %s.",
2246 [JOB_FAILED] = "Failed stopping %s.",
2247 [JOB_TIMEOUT] = "Timed out stopping %s.",