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>
30 #include <netinet/tcp.h>
32 #include <sys/xattr.h>
36 #include "load-dropin.h"
37 #include "load-fragment.h"
40 #include "path-util.h"
41 #include "unit-name.h"
42 #include "unit-printf.h"
46 #include "exit-status.h"
48 #include "smack-util.h"
50 #include "bus-error.h"
51 #include "dbus-socket.h"
55 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
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,
65 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
66 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
67 [SOCKET_FAILED] = UNIT_FAILED
70 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
71 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
73 static void socket_init(Unit *u) {
74 Socket *s = SOCKET(u);
77 assert(u->load_state == UNIT_STUB);
79 s->backlog = SOMAXCONN;
80 s->timeout_usec = u->manager->default_timeout_start_usec;
81 s->directory_mode = 0755;
82 s->socket_mode = 0666;
84 s->max_connections = 64;
91 s->exec_context.std_output = u->manager->default_std_output;
92 s->exec_context.std_error = u->manager->default_std_error;
94 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
97 static void socket_unwatch_control_pid(Socket *s) {
100 if (s->control_pid <= 0)
103 unit_unwatch_pid(UNIT(s), s->control_pid);
107 void socket_free_ports(Socket *s) {
112 while ((p = s->ports)) {
113 LIST_REMOVE(port, s->ports, p);
115 sd_event_source_unref(p->event_source);
123 static void socket_done(Unit *u) {
124 Socket *s = SOCKET(u);
128 socket_free_ports(s);
130 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
131 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
132 s->control_command = NULL;
134 socket_unwatch_control_pid(s);
136 unit_ref_unset(&s->service);
138 free(s->tcp_congestion);
139 s->tcp_congestion = NULL;
141 free(s->bind_to_device);
142 s->bind_to_device = NULL;
145 free(s->smack_ip_in);
146 free(s->smack_ip_out);
148 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
151 static int socket_arm_timer(Socket *s) {
156 if (s->timeout_usec <= 0) {
157 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
161 if (s->timer_event_source) {
162 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec);
166 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
169 return sd_event_add_time(
170 UNIT(s)->manager->event,
171 &s->timer_event_source,
173 now(CLOCK_MONOTONIC) + s->timeout_usec, 0,
174 socket_dispatch_timer, s);
177 static int socket_instantiate_service(Socket *s) {
178 _cleanup_free_ char *prefix = NULL;
179 _cleanup_free_ char *name = NULL;
185 /* This fills in s->service if it isn't filled in yet. For
186 * Accept=yes sockets we create the next connection service
187 * here. For Accept=no this is mostly a NOP since the service
188 * is figured out at load time anyway. */
190 if (UNIT_DEREF(s->service))
195 prefix = unit_name_to_prefix(UNIT(s)->id);
199 if (asprintf(&name, "%s@%u.service", prefix, s->n_accepted) < 0)
202 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
206 #ifdef HAVE_SYSV_COMPAT
207 if (SERVICE(u)->is_sysv) {
208 log_error("Using SysV services for socket activation is not supported. Refusing.");
214 unit_ref_set(&s->service, u);
216 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
219 static bool have_non_accept_socket(Socket *s) {
227 LIST_FOREACH(port, p, s->ports) {
229 if (p->type != SOCKET_SOCKET)
232 if (!socket_address_can_accept(&p->address))
239 static int socket_add_mount_links(Socket *s) {
245 LIST_FOREACH(port, p, s->ports) {
246 const char *path = NULL;
248 if (p->type == SOCKET_SOCKET)
249 path = socket_address_get_path(&p->address);
250 else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL)
256 r = unit_require_mounts_for(UNIT(s), path);
264 static int socket_add_device_link(Socket *s) {
269 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
272 t = strappenda("/sys/subsystem/net/devices/", s->bind_to_device);
273 return unit_add_node_link(UNIT(s), t, false);
276 static int socket_add_default_dependencies(Socket *s) {
280 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
284 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
285 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
290 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
293 _pure_ static bool socket_has_exec(Socket *s) {
297 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
298 if (s->exec_command[i])
304 static int socket_add_extras(Socket *s) {
310 if (have_non_accept_socket(s)) {
312 if (!UNIT_DEREF(s->service)) {
315 r = unit_load_related_unit(u, ".service", &x);
319 unit_ref_set(&s->service, x);
322 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
327 r = socket_add_mount_links(s);
331 r = socket_add_device_link(s);
335 r = unit_patch_contexts(u);
339 if (socket_has_exec(s)) {
340 r = unit_add_exec_dependencies(u, &s->exec_context);
344 r = unit_add_default_slice(u, &s->cgroup_context);
349 if (u->default_dependencies) {
350 r = socket_add_default_dependencies(s);
358 static int socket_verify(Socket *s) {
361 if (UNIT(s)->load_state != UNIT_LOADED)
365 log_error_unit(UNIT(s)->id, "%s lacks Listen setting. Refusing.", UNIT(s)->id);
369 if (s->accept && have_non_accept_socket(s)) {
370 log_error_unit(UNIT(s)->id, "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
375 if (s->accept && s->max_connections <= 0) {
376 log_error_unit(UNIT(s)->id, "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
380 if (s->accept && UNIT_DEREF(s->service)) {
381 log_error_unit(UNIT(s)->id, "Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
385 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
386 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
393 static int socket_load(Unit *u) {
394 Socket *s = SOCKET(u);
398 assert(u->load_state == UNIT_STUB);
400 r = unit_load_fragment_and_dropin(u);
404 if (u->load_state == UNIT_LOADED) {
405 /* This is a new unit? Then let's add in some extras */
406 r = socket_add_extras(s);
411 return socket_verify(s);
414 _const_ static const char* listen_lookup(int family, int type) {
416 if (family == AF_NETLINK)
417 return "ListenNetlink";
419 if (type == SOCK_STREAM)
420 return "ListenStream";
421 else if (type == SOCK_DGRAM)
422 return "ListenDatagram";
423 else if (type == SOCK_SEQPACKET)
424 return "ListenSequentialPacket";
426 assert_not_reached("Unknown socket type");
430 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
432 Socket *s = SOCKET(u);
439 prefix2 = strappenda(prefix, "\t");
442 "%sSocket State: %s\n"
444 "%sBindIPv6Only: %s\n"
446 "%sSocketMode: %04o\n"
447 "%sDirectoryMode: %04o\n"
450 "%sTransparent: %s\n"
452 "%sPassCredentials: %s\n"
453 "%sPassSecurity: %s\n"
454 "%sTCPCongestion: %s\n"
455 "%sRemoveOnStop: %s\n",
456 prefix, socket_state_to_string(s->state),
457 prefix, socket_result_to_string(s->result),
458 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
460 prefix, s->socket_mode,
461 prefix, s->directory_mode,
462 prefix, yes_no(s->keep_alive),
463 prefix, yes_no(s->free_bind),
464 prefix, yes_no(s->transparent),
465 prefix, yes_no(s->broadcast),
466 prefix, yes_no(s->pass_cred),
467 prefix, yes_no(s->pass_sec),
468 prefix, strna(s->tcp_congestion),
469 prefix, yes_no(s->remove_on_stop));
471 if (s->control_pid > 0)
473 "%sControl PID: "PID_FMT"\n",
474 prefix, s->control_pid);
476 if (s->bind_to_device)
478 "%sBindToDevice: %s\n",
479 prefix, s->bind_to_device);
484 "%sNConnections: %u\n"
485 "%sMaxConnections: %u\n",
486 prefix, s->n_accepted,
487 prefix, s->n_connections,
488 prefix, s->max_connections);
490 if (s->priority >= 0)
493 prefix, s->priority);
495 if (s->receive_buffer > 0)
497 "%sReceiveBuffer: %zu\n",
498 prefix, s->receive_buffer);
500 if (s->send_buffer > 0)
502 "%sSendBuffer: %zu\n",
503 prefix, s->send_buffer);
515 if (s->pipe_size > 0)
518 prefix, s->pipe_size);
525 if (s->mq_maxmsg > 0)
527 "%sMessageQueueMaxMessages: %li\n",
528 prefix, s->mq_maxmsg);
530 if (s->mq_msgsize > 0)
532 "%sMessageQueueMessageSize: %li\n",
533 prefix, s->mq_msgsize);
538 prefix, yes_no(s->reuse_port));
542 "%sSmackLabel: %s\n",
547 "%sSmackLabelIPIn: %s\n",
548 prefix, s->smack_ip_in);
552 "%sSmackLabelIPOut: %s\n",
553 prefix, s->smack_ip_out);
555 LIST_FOREACH(port, p, s->ports) {
557 if (p->type == SOCKET_SOCKET) {
562 if ((r = socket_address_print(&p->address, &k)) < 0)
567 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
569 } else if (p->type == SOCKET_SPECIAL)
570 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
571 else if (p->type == SOCKET_MQUEUE)
572 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
574 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
577 exec_context_dump(&s->exec_context, f, prefix);
578 kill_context_dump(&s->kill_context, f, prefix);
580 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
581 if (!s->exec_command[c])
584 fprintf(f, "%s-> %s:\n",
585 prefix, socket_exec_command_to_string(c));
587 exec_command_dump_list(s->exec_command[c], f, prefix2);
591 static int instance_from_socket(int fd, unsigned nr, char **instance) {
594 union sockaddr_union local, remote;
600 if (getsockname(fd, &local.sa, &l) < 0)
604 if (getpeername(fd, &remote.sa, &l) < 0)
607 switch (local.sa.sa_family) {
611 a = ntohl(local.in.sin_addr.s_addr),
612 b = ntohl(remote.in.sin_addr.s_addr);
615 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
617 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
618 ntohs(local.in.sin_port),
619 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
620 ntohs(remote.in.sin_port)) < 0)
627 static const unsigned char ipv4_prefix[] = {
628 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
631 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
632 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
634 *a = local.in6.sin6_addr.s6_addr+12,
635 *b = remote.in6.sin6_addr.s6_addr+12;
638 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
640 a[0], a[1], a[2], a[3],
641 ntohs(local.in6.sin6_port),
642 b[0], b[1], b[2], b[3],
643 ntohs(remote.in6.sin6_port)) < 0)
646 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
651 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
652 ntohs(local.in6.sin6_port),
653 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
654 ntohs(remote.in6.sin6_port)) < 0)
665 k = getpeercred(fd, &ucred);
668 "%u-"PID_FMT"-"UID_FMT,
669 nr, ucred.pid, ucred.uid) < 0)
671 } else if (k == -ENODATA) {
672 /* This handles the case where somebody is
673 * connecting from another pid/uid namespace
674 * (e.g. from outside of our container). */
686 assert_not_reached("Unhandled socket type.");
693 static void socket_close_fds(Socket *s) {
698 LIST_FOREACH(port, p, s->ports) {
700 p->event_source = sd_event_source_unref(p->event_source);
705 p->fd = safe_close(p->fd);
707 /* One little note: we should normally not delete any
708 * sockets in the file system here! After all some
709 * other process we spawned might still have a
710 * reference of this fd and wants to continue to use
711 * it. Therefore we delete sockets in the file system
712 * before we create a new one, not after we stopped
715 if (s->remove_on_stop) {
727 socket_address_unlink(&p->address);
737 static void socket_apply_socket_options(Socket *s, int fd) {
742 int b = s->keep_alive;
743 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
744 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
749 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
750 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
755 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
756 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
761 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
762 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
765 if (s->priority >= 0)
766 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
767 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
769 if (s->receive_buffer > 0) {
770 int value = (int) s->receive_buffer;
772 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
774 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
775 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
776 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
779 if (s->send_buffer > 0) {
780 int value = (int) s->send_buffer;
781 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
782 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
783 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
787 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
788 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
791 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
792 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
794 if (s->ip_ttl >= 0) {
797 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
799 if (socket_ipv6_is_supported())
800 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
803 errno = EAFNOSUPPORT;
807 log_warning_unit(UNIT(s)->id,
808 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
811 if (s->tcp_congestion)
812 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
813 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
816 int b = s->reuse_port;
817 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)) < 0)
818 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
822 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
823 log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
826 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
827 log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
830 static void socket_apply_fifo_options(Socket *s, int fd) {
834 if (s->pipe_size > 0)
835 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
836 log_warning_unit(UNIT(s)->id,
840 if (smack_label_fd(fd, s->smack) < 0)
841 log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
844 static int fifo_address_create(
846 mode_t directory_mode,
857 mkdir_parents_label(path, directory_mode);
859 r = label_context_set(path, S_IFIFO);
863 /* Enforce the right access mode for the fifo */
864 old_mask = umask(~ socket_mode);
866 /* Include the original umask in our mask */
867 umask(~socket_mode | old_mask);
869 r = mkfifo(path, socket_mode);
872 if (r < 0 && errno != EEXIST) {
877 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
882 label_context_clear();
884 if (fstat(fd, &st) < 0) {
889 if (!S_ISFIFO(st.st_mode) ||
890 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
891 st.st_uid != getuid() ||
892 st.st_gid != getgid()) {
902 label_context_clear();
908 static int special_address_create(
918 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
923 if (fstat(fd, &st) < 0) {
928 /* Check whether this is a /proc, /sys or /dev file or char device */
929 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
943 static int mq_address_create(
953 struct mq_attr _attr, *attr = NULL;
958 if (maxmsg > 0 && msgsize > 0) {
960 _attr.mq_flags = O_NONBLOCK;
961 _attr.mq_maxmsg = maxmsg;
962 _attr.mq_msgsize = msgsize;
966 /* Enforce the right access mode for the mq */
967 old_mask = umask(~ mq_mode);
969 /* Include the original umask in our mask */
970 umask(~mq_mode | old_mask);
972 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
980 if (fstat(fd, &st) < 0) {
985 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
986 st.st_uid != getuid() ||
987 st.st_gid != getgid()) {
1001 static int socket_open_fds(Socket *s) {
1005 bool know_label = false;
1009 LIST_FOREACH(port, p, s->ports) {
1014 if (p->type == SOCKET_SOCKET) {
1018 r = socket_instantiate_service(s);
1022 if (UNIT_ISSET(s->service) &&
1023 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1024 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1025 if (r < 0 && r != -EPERM)
1032 r = socket_address_listen(
1034 SOCK_CLOEXEC|SOCK_NONBLOCK,
1047 socket_apply_socket_options(s, p->fd);
1049 } else if (p->type == SOCKET_SPECIAL) {
1051 r = special_address_create(
1057 } else if (p->type == SOCKET_FIFO) {
1059 r = fifo_address_create(
1067 socket_apply_fifo_options(s, p->fd);
1068 } else if (p->type == SOCKET_MQUEUE) {
1070 r = mq_address_create(
1079 assert_not_reached("Unknown port type");
1086 socket_close_fds(s);
1091 static void socket_unwatch_fds(Socket *s) {
1097 LIST_FOREACH(port, p, s->ports) {
1101 if (p->event_source) {
1102 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_OFF);
1104 log_debug_unit(UNIT(s)->id, "Failed to disable event source.");
1109 static int socket_watch_fds(Socket *s) {
1115 LIST_FOREACH(port, p, s->ports) {
1119 if (p->event_source)
1120 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1122 r = sd_event_add_io(UNIT(s)->manager->event, &p->event_source, p->fd, EPOLLIN, socket_dispatch_io, p);
1125 log_warning_unit(UNIT(s)->id, "Failed to watch listening fds: %s", strerror(-r));
1133 socket_unwatch_fds(s);
1137 static void socket_set_state(Socket *s, SocketState state) {
1138 SocketState old_state;
1141 old_state = s->state;
1148 SOCKET_STOP_PRE_SIGTERM,
1149 SOCKET_STOP_PRE_SIGKILL,
1151 SOCKET_FINAL_SIGTERM,
1152 SOCKET_FINAL_SIGKILL)) {
1154 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1155 socket_unwatch_control_pid(s);
1156 s->control_command = NULL;
1157 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1160 if (state != SOCKET_LISTENING)
1161 socket_unwatch_fds(s);
1168 SOCKET_STOP_PRE_SIGTERM,
1169 SOCKET_STOP_PRE_SIGKILL))
1170 socket_close_fds(s);
1172 if (state != old_state)
1173 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s",
1174 UNIT(s)->id, socket_state_to_string(old_state), socket_state_to_string(state));
1176 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1179 static int socket_coldplug(Unit *u) {
1180 Socket *s = SOCKET(u);
1184 assert(s->state == SOCKET_DEAD);
1186 if (s->deserialized_state == s->state)
1189 if (s->deserialized_state == SOCKET_START_PRE ||
1190 s->deserialized_state == SOCKET_START_POST ||
1191 s->deserialized_state == SOCKET_STOP_PRE ||
1192 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1193 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1194 s->deserialized_state == SOCKET_STOP_POST ||
1195 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1196 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1198 if (s->control_pid <= 0)
1201 r = unit_watch_pid(UNIT(s), s->control_pid);
1205 r = socket_arm_timer(s);
1210 if (s->deserialized_state == SOCKET_START_POST ||
1211 s->deserialized_state == SOCKET_LISTENING ||
1212 s->deserialized_state == SOCKET_RUNNING ||
1213 s->deserialized_state == SOCKET_STOP_PRE ||
1214 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1215 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL) {
1216 r = socket_open_fds(s);
1221 if (s->deserialized_state == SOCKET_LISTENING) {
1222 r = socket_watch_fds(s);
1227 socket_set_state(s, s->deserialized_state);
1231 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1240 unit_realize_cgroup(UNIT(s));
1242 r = unit_setup_exec_runtime(UNIT(s));
1246 r = socket_arm_timer(s);
1250 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1258 UNIT(s)->manager->environment,
1262 UNIT(s)->manager->confirm_spawn,
1263 UNIT(s)->manager->cgroup_supported,
1264 UNIT(s)->cgroup_path,
1265 manager_get_runtime_prefix(UNIT(s)->manager),
1276 r = unit_watch_pid(UNIT(s), pid);
1278 /* FIXME: we need to do something here */
1286 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1291 static void socket_enter_dead(Socket *s, SocketResult f) {
1294 if (f != SOCKET_SUCCESS)
1297 exec_runtime_destroy(s->exec_runtime);
1298 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1300 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1302 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1305 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1307 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1311 if (f != SOCKET_SUCCESS)
1314 socket_unwatch_control_pid(s);
1316 s->control_command_id = SOCKET_EXEC_STOP_POST;
1318 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1319 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1322 socket_set_state(s, SOCKET_STOP_POST);
1324 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1329 log_warning_unit(UNIT(s)->id,
1330 "%s failed to run 'stop-post' task: %s",
1331 UNIT(s)->id, strerror(-r));
1332 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1335 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1340 if (f != SOCKET_SUCCESS)
1343 r = unit_kill_context(
1346 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1354 r = socket_arm_timer(s);
1358 socket_set_state(s, state);
1359 } else if (state == SOCKET_STOP_PRE_SIGTERM)
1360 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_SUCCESS);
1361 else if (state == SOCKET_STOP_PRE_SIGKILL)
1362 socket_enter_stop_post(s, SOCKET_SUCCESS);
1363 else if (state == SOCKET_FINAL_SIGTERM)
1364 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
1366 socket_enter_dead(s, SOCKET_SUCCESS);
1371 log_warning_unit(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1373 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1374 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1376 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1379 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1383 if (f != SOCKET_SUCCESS)
1386 socket_unwatch_control_pid(s);
1388 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1390 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1391 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1394 socket_set_state(s, SOCKET_STOP_PRE);
1396 socket_enter_stop_post(s, SOCKET_SUCCESS);
1401 log_warning_unit(UNIT(s)->id, "%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1402 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1405 static void socket_enter_listening(Socket *s) {
1409 r = socket_watch_fds(s);
1411 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1415 socket_set_state(s, SOCKET_LISTENING);
1419 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1422 static void socket_enter_start_post(Socket *s) {
1426 r = socket_open_fds(s);
1428 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1432 socket_unwatch_control_pid(s);
1434 s->control_command_id = SOCKET_EXEC_START_POST;
1436 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1437 r = socket_spawn(s, s->control_command, &s->control_pid);
1439 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1443 socket_set_state(s, SOCKET_START_POST);
1445 socket_enter_listening(s);
1450 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1453 static void socket_enter_start_pre(Socket *s) {
1457 socket_unwatch_control_pid(s);
1459 s->control_command_id = SOCKET_EXEC_START_PRE;
1461 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1462 r = socket_spawn(s, s->control_command, &s->control_pid);
1466 socket_set_state(s, SOCKET_START_PRE);
1468 socket_enter_start_post(s);
1473 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1474 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1477 static void socket_enter_running(Socket *s, int cfd) {
1478 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1483 /* We don't take connections anymore if we are supposed to
1484 * shut down anyway */
1485 if (unit_stop_pending(UNIT(s))) {
1487 log_debug_unit(UNIT(s)->id, "Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1492 /* Flush all sockets by closing and reopening them */
1493 socket_close_fds(s);
1495 r = socket_open_fds(s);
1497 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1498 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1502 r = socket_watch_fds(s);
1504 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1505 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1515 bool pending = false;
1517 /* If there's already a start pending don't bother to
1519 SET_FOREACH(other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1520 if (unit_active_or_pending(other)) {
1526 if (!UNIT_ISSET(s->service)) {
1527 log_error_unit(UNIT(s)->id, "%s: service to activate vanished, refusing activation.", UNIT(s)->id);
1532 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1537 socket_set_state(s, SOCKET_RUNNING);
1539 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1542 if (s->n_connections >= s->max_connections) {
1543 log_warning_unit(UNIT(s)->id, "%s: Too many incoming connections (%u)", UNIT(s)->id, s->n_connections);
1548 r = socket_instantiate_service(s);
1552 r = instance_from_socket(cfd, s->n_accepted, &instance);
1557 /* ENOTCONN is legitimate if TCP RST was received.
1558 * This connection is over, but the socket unit lives on. */
1563 prefix = unit_name_to_prefix(UNIT(s)->id);
1569 name = unit_name_build(prefix, instance, ".service");
1575 r = unit_add_name(UNIT_DEREF(s->service), name);
1579 service = SERVICE(UNIT_DEREF(s->service));
1580 unit_ref_unset(&s->service);
1583 UNIT(service)->no_gc = false;
1585 unit_choose_id(UNIT(service), name);
1587 r = service_set_socket_fd(service, cfd, s);
1592 s->n_connections ++;
1594 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1598 /* Notify clients about changed counters */
1599 unit_add_to_dbus_queue(UNIT(s));
1605 log_warning_unit(UNIT(s)->id, "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1606 UNIT(s)->id, cfd >= 0 ? "template" : "non-template",
1607 bus_error_message(&error, r));
1609 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1613 static void socket_run_next(Socket *s) {
1617 assert(s->control_command);
1618 assert(s->control_command->command_next);
1620 socket_unwatch_control_pid(s);
1622 s->control_command = s->control_command->command_next;
1624 r = socket_spawn(s, s->control_command, &s->control_pid);
1631 log_warning_unit(UNIT(s)->id, "%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1633 if (s->state == SOCKET_START_POST)
1634 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1635 else if (s->state == SOCKET_STOP_POST)
1636 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1638 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1641 static int socket_start(Unit *u) {
1642 Socket *s = SOCKET(u);
1646 /* We cannot fulfill this request right now, try again later
1648 if (s->state == SOCKET_STOP_PRE ||
1649 s->state == SOCKET_STOP_PRE_SIGKILL ||
1650 s->state == SOCKET_STOP_PRE_SIGTERM ||
1651 s->state == SOCKET_STOP_POST ||
1652 s->state == SOCKET_FINAL_SIGTERM ||
1653 s->state == SOCKET_FINAL_SIGKILL)
1656 if (s->state == SOCKET_START_PRE ||
1657 s->state == SOCKET_START_POST)
1660 /* Cannot run this without the service being around */
1661 if (UNIT_ISSET(s->service)) {
1664 service = SERVICE(UNIT_DEREF(s->service));
1666 if (UNIT(service)->load_state != UNIT_LOADED) {
1667 log_error_unit(u->id, "Socket service %s not loaded, refusing.", UNIT(service)->id);
1671 /* If the service is already active we cannot start the
1673 if (service->state != SERVICE_DEAD &&
1674 service->state != SERVICE_FAILED &&
1675 service->state != SERVICE_AUTO_RESTART) {
1676 log_error_unit(u->id, "Socket service %s already active, refusing.", UNIT(service)->id);
1680 #ifdef HAVE_SYSV_COMPAT
1681 if (service->is_sysv) {
1682 log_error_unit(u->id,
1683 "Using SysV services for socket activation is not supported. Refusing.");
1689 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1691 s->result = SOCKET_SUCCESS;
1692 socket_enter_start_pre(s);
1697 static int socket_stop(Unit *u) {
1698 Socket *s = SOCKET(u);
1703 if (s->state == SOCKET_STOP_PRE ||
1704 s->state == SOCKET_STOP_PRE_SIGTERM ||
1705 s->state == SOCKET_STOP_PRE_SIGKILL ||
1706 s->state == SOCKET_STOP_POST ||
1707 s->state == SOCKET_FINAL_SIGTERM ||
1708 s->state == SOCKET_FINAL_SIGKILL)
1711 /* If there's already something running we go directly into
1713 if (s->state == SOCKET_START_PRE ||
1714 s->state == SOCKET_START_POST) {
1715 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1719 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1721 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1725 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1726 Socket *s = SOCKET(u);
1734 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1735 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1736 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1738 if (s->control_pid > 0)
1739 unit_serialize_item_format(u, f, "control-pid", PID_FMT, s->control_pid);
1741 if (s->control_command_id >= 0)
1742 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1744 LIST_FOREACH(port, p, s->ports) {
1750 copy = fdset_put_dup(fds, p->fd);
1754 if (p->type == SOCKET_SOCKET) {
1755 _cleanup_free_ char *t = NULL;
1757 r = socket_address_print(&p->address, &t);
1761 if (socket_address_family(&p->address) == AF_NETLINK)
1762 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1764 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1766 } else if (p->type == SOCKET_SPECIAL)
1767 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1768 else if (p->type == SOCKET_MQUEUE)
1769 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1771 assert(p->type == SOCKET_FIFO);
1772 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1779 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1780 Socket *s = SOCKET(u);
1786 if (streq(key, "state")) {
1789 state = socket_state_from_string(value);
1791 log_debug_unit(u->id, "Failed to parse state value %s", value);
1793 s->deserialized_state = state;
1794 } else if (streq(key, "result")) {
1797 f = socket_result_from_string(value);
1799 log_debug_unit(u->id, "Failed to parse result value %s", value);
1800 else if (f != SOCKET_SUCCESS)
1803 } else if (streq(key, "n-accepted")) {
1806 if (safe_atou(value, &k) < 0)
1807 log_debug_unit(u->id, "Failed to parse n-accepted value %s", value);
1810 } else if (streq(key, "control-pid")) {
1813 if (parse_pid(value, &pid) < 0)
1814 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1816 s->control_pid = pid;
1817 } else if (streq(key, "control-command")) {
1818 SocketExecCommand id;
1820 id = socket_exec_command_from_string(value);
1822 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1824 s->control_command_id = id;
1825 s->control_command = s->exec_command[id];
1827 } else if (streq(key, "fifo")) {
1831 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1832 log_debug_unit(u->id, "Failed to parse fifo value %s", value);
1835 LIST_FOREACH(port, p, s->ports)
1836 if (p->type == SOCKET_FIFO &&
1837 streq_ptr(p->path, value+skip))
1842 p->fd = fdset_remove(fds, fd);
1846 } else if (streq(key, "special")) {
1850 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1851 log_debug_unit(u->id, "Failed to parse special value %s", value);
1854 LIST_FOREACH(port, p, s->ports)
1855 if (p->type == SOCKET_SPECIAL &&
1856 streq_ptr(p->path, value+skip))
1861 p->fd = fdset_remove(fds, fd);
1865 } else if (streq(key, "mqueue")) {
1869 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1870 log_debug_unit(u->id, "Failed to parse mqueue value %s", value);
1873 LIST_FOREACH(port, p, s->ports)
1874 if (p->type == SOCKET_MQUEUE &&
1875 streq_ptr(p->path, value+skip))
1880 p->fd = fdset_remove(fds, fd);
1884 } else if (streq(key, "socket")) {
1885 int fd, type, skip = 0;
1888 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1889 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1892 LIST_FOREACH(port, p, s->ports)
1893 if (socket_address_is(&p->address, value+skip, type))
1898 p->fd = fdset_remove(fds, fd);
1902 } else if (streq(key, "netlink")) {
1906 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1907 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1910 LIST_FOREACH(port, p, s->ports)
1911 if (socket_address_is_netlink(&p->address, value+skip))
1916 p->fd = fdset_remove(fds, fd);
1920 log_debug_unit(UNIT(s)->id, "Unknown serialization key '%s'", key);
1925 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1926 Socket *s = SOCKET(u);
1931 LIST_FOREACH(port, p, s->ports) {
1935 if (p->type != SOCKET_SOCKET)
1941 FDSET_FOREACH(fd, fds, i) {
1942 if (socket_address_matches_fd(&p->address, fd)) {
1943 p->fd = fdset_remove(fds, fd);
1944 s->deserialized_state = SOCKET_LISTENING;
1953 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1956 return state_translation_table[SOCKET(u)->state];
1959 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1962 return socket_state_to_string(SOCKET(u)->state);
1965 const char* socket_port_type_to_string(SocketPort *p) {
1973 switch (p->address.type) {
1981 case SOCK_SEQPACKET:
1982 return "SequentialPacket";
1985 if (socket_address_family(&p->address) == AF_NETLINK)
1992 case SOCKET_SPECIAL:
1996 return "MessageQueue";
2006 _pure_ static bool socket_check_gc(Unit *u) {
2007 Socket *s = SOCKET(u);
2011 return s->n_connections > 0;
2014 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2015 SocketPort *p = userdata;
2021 if (p->socket->state != SOCKET_LISTENING)
2024 log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
2026 if (revents != EPOLLIN) {
2028 if (revents & EPOLLHUP)
2029 log_error_unit(UNIT(p->socket)->id, "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
2030 UNIT(p->socket)->id);
2032 log_error_unit(UNIT(p->socket)->id, "%s: Got unexpected poll event (0x%x) on socket.",
2033 UNIT(p->socket)->id, revents);
2038 if (p->socket->accept &&
2039 p->type == SOCKET_SOCKET &&
2040 socket_address_can_accept(&p->address)) {
2044 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2050 log_error_unit(UNIT(p->socket)->id,
2051 "Failed to accept socket: %m");
2058 socket_apply_socket_options(p->socket, cfd);
2061 socket_enter_running(p->socket, cfd);
2065 socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2069 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2070 Socket *s = SOCKET(u);
2076 if (pid != s->control_pid)
2081 if (is_clean_exit(code, status, NULL))
2083 else if (code == CLD_EXITED)
2084 f = SOCKET_FAILURE_EXIT_CODE;
2085 else if (code == CLD_KILLED)
2086 f = SOCKET_FAILURE_SIGNAL;
2087 else if (code == CLD_DUMPED)
2088 f = SOCKET_FAILURE_CORE_DUMP;
2090 assert_not_reached("Unknown code");
2092 if (s->control_command) {
2093 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2095 if (s->control_command->ignore)
2099 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2101 "%s control process exited, code=%s status=%i",
2102 u->id, sigchld_code_to_string(code), status);
2104 if (f != SOCKET_SUCCESS)
2107 if (s->control_command &&
2108 s->control_command->command_next &&
2109 f == SOCKET_SUCCESS) {
2111 log_debug_unit(u->id,
2112 "%s running next command for state %s",
2113 u->id, socket_state_to_string(s->state));
2116 s->control_command = NULL;
2117 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2119 /* No further commands for this step, so let's figure
2120 * out what to do next */
2122 log_debug_unit(u->id,
2123 "%s got final SIGCHLD for state %s",
2124 u->id, socket_state_to_string(s->state));
2128 case SOCKET_START_PRE:
2129 if (f == SOCKET_SUCCESS)
2130 socket_enter_start_post(s);
2132 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2135 case SOCKET_START_POST:
2136 if (f == SOCKET_SUCCESS)
2137 socket_enter_listening(s);
2139 socket_enter_stop_pre(s, f);
2142 case SOCKET_STOP_PRE:
2143 case SOCKET_STOP_PRE_SIGTERM:
2144 case SOCKET_STOP_PRE_SIGKILL:
2145 socket_enter_stop_post(s, f);
2148 case SOCKET_STOP_POST:
2149 case SOCKET_FINAL_SIGTERM:
2150 case SOCKET_FINAL_SIGKILL:
2151 socket_enter_dead(s, f);
2155 assert_not_reached("Uh, control process died at wrong time.");
2159 /* Notify clients about changed exit status */
2160 unit_add_to_dbus_queue(u);
2163 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2164 Socket *s = SOCKET(userdata);
2167 assert(s->timer_event_source == source);
2171 case SOCKET_START_PRE:
2172 log_warning_unit(UNIT(s)->id,
2173 "%s starting timed out. Terminating.", UNIT(s)->id);
2174 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2177 case SOCKET_START_POST:
2178 log_warning_unit(UNIT(s)->id,
2179 "%s starting timed out. Stopping.", UNIT(s)->id);
2180 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2183 case SOCKET_STOP_PRE:
2184 log_warning_unit(UNIT(s)->id,
2185 "%s stopping timed out. Terminating.", UNIT(s)->id);
2186 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2189 case SOCKET_STOP_PRE_SIGTERM:
2190 if (s->kill_context.send_sigkill) {
2191 log_warning_unit(UNIT(s)->id,
2192 "%s stopping timed out. Killing.", UNIT(s)->id);
2193 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2195 log_warning_unit(UNIT(s)->id,
2196 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2198 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2202 case SOCKET_STOP_PRE_SIGKILL:
2203 log_warning_unit(UNIT(s)->id,
2204 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2205 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2208 case SOCKET_STOP_POST:
2209 log_warning_unit(UNIT(s)->id,
2210 "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2211 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2214 case SOCKET_FINAL_SIGTERM:
2215 if (s->kill_context.send_sigkill) {
2216 log_warning_unit(UNIT(s)->id,
2217 "%s stopping timed out (2). Killing.", UNIT(s)->id);
2218 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2220 log_warning_unit(UNIT(s)->id,
2221 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2223 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2227 case SOCKET_FINAL_SIGKILL:
2228 log_warning_unit(UNIT(s)->id,
2229 "%s still around after SIGKILL (2). Entering failed mode.",
2231 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2235 assert_not_reached("Timeout at wrong time.");
2241 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2250 /* Called from the service code for requesting our fds */
2253 LIST_FOREACH(port, p, s->ports)
2263 if (!(rfds = new(int, rn_fds)))
2267 LIST_FOREACH(port, p, s->ports)
2271 assert(k == rn_fds);
2279 static void socket_reset_failed(Unit *u) {
2280 Socket *s = SOCKET(u);
2284 if (s->state == SOCKET_FAILED)
2285 socket_set_state(s, SOCKET_DEAD);
2287 s->result = SOCKET_SUCCESS;
2290 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2293 /* The service is dead. Dang!
2295 * This is strictly for one-instance-for-all-connections
2298 if (s->state == SOCKET_RUNNING) {
2299 log_debug_unit(UNIT(s)->id, "%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2300 if (failed_permanent)
2301 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2303 socket_enter_listening(s);
2307 void socket_connection_unref(Socket *s) {
2310 /* The service is dead. Yay!
2312 * This is strictly for one-instance-per-connection
2315 assert(s->n_connections > 0);
2318 log_debug_unit(UNIT(s)->id, "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2321 static void socket_trigger_notify(Unit *u, Unit *other) {
2322 Socket *s = SOCKET(u);
2328 /* Don't propagate state changes from the service if we are
2329 already down or accepting connections */
2330 if ((s->state != SOCKET_RUNNING &&
2331 s->state != SOCKET_LISTENING) ||
2335 if (other->load_state != UNIT_LOADED ||
2336 other->type != UNIT_SERVICE)
2339 se = SERVICE(other);
2341 if (se->state == SERVICE_FAILED)
2342 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2344 if (se->state == SERVICE_DEAD ||
2345 se->state == SERVICE_STOP ||
2346 se->state == SERVICE_STOP_SIGTERM ||
2347 se->state == SERVICE_STOP_SIGKILL ||
2348 se->state == SERVICE_STOP_POST ||
2349 se->state == SERVICE_FINAL_SIGTERM ||
2350 se->state == SERVICE_FINAL_SIGKILL ||
2351 se->state == SERVICE_AUTO_RESTART)
2352 socket_notify_service_dead(s, false);
2354 if (se->state == SERVICE_RUNNING)
2355 socket_set_state(s, SOCKET_RUNNING);
2358 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2359 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2362 static int socket_get_timeout(Unit *u, uint64_t *timeout) {
2363 Socket *s = SOCKET(u);
2366 if (!s->timer_event_source)
2369 r = sd_event_source_get_time(s->timer_event_source, timeout);
2376 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2377 [SOCKET_DEAD] = "dead",
2378 [SOCKET_START_PRE] = "start-pre",
2379 [SOCKET_START_POST] = "start-post",
2380 [SOCKET_LISTENING] = "listening",
2381 [SOCKET_RUNNING] = "running",
2382 [SOCKET_STOP_PRE] = "stop-pre",
2383 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2384 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2385 [SOCKET_STOP_POST] = "stop-post",
2386 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2387 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2388 [SOCKET_FAILED] = "failed"
2391 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2393 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2394 [SOCKET_EXEC_START_PRE] = "StartPre",
2395 [SOCKET_EXEC_START_POST] = "StartPost",
2396 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2397 [SOCKET_EXEC_STOP_POST] = "StopPost"
2400 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2402 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2403 [SOCKET_SUCCESS] = "success",
2404 [SOCKET_FAILURE_RESOURCES] = "resources",
2405 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2406 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2407 [SOCKET_FAILURE_SIGNAL] = "signal",
2408 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2409 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2412 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2414 const UnitVTable socket_vtable = {
2415 .object_size = sizeof(Socket),
2416 .exec_context_offset = offsetof(Socket, exec_context),
2417 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2418 .kill_context_offset = offsetof(Socket, kill_context),
2419 .exec_runtime_offset = offsetof(Socket, exec_runtime),
2425 .private_section = "Socket",
2427 .init = socket_init,
2428 .done = socket_done,
2429 .load = socket_load,
2431 .coldplug = socket_coldplug,
2433 .dump = socket_dump,
2435 .start = socket_start,
2436 .stop = socket_stop,
2438 .kill = socket_kill,
2440 .get_timeout = socket_get_timeout,
2442 .serialize = socket_serialize,
2443 .deserialize_item = socket_deserialize_item,
2444 .distribute_fds = socket_distribute_fds,
2446 .active_state = socket_active_state,
2447 .sub_state_to_string = socket_sub_state_to_string,
2449 .check_gc = socket_check_gc,
2451 .sigchld_event = socket_sigchld_event,
2453 .trigger_notify = socket_trigger_notify,
2455 .reset_failed = socket_reset_failed,
2457 .bus_interface = "org.freedesktop.systemd1.Socket",
2458 .bus_vtable = bus_socket_vtable,
2459 .bus_set_property = bus_socket_set_property,
2460 .bus_commit_properties = bus_socket_commit_properties,
2462 .status_message_formats = {
2463 /*.starting_stopping = {
2464 [0] = "Starting socket %s...",
2465 [1] = "Stopping socket %s...",
2467 .finished_start_job = {
2468 [JOB_DONE] = "Listening on %s.",
2469 [JOB_FAILED] = "Failed to listen on %s.",
2470 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2471 [JOB_TIMEOUT] = "Timed out starting %s.",
2473 .finished_stop_job = {
2474 [JOB_DONE] = "Closed %s.",
2475 [JOB_FAILED] = "Failed stopping %s.",
2476 [JOB_TIMEOUT] = "Timed out stopping %s.",