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 prefix, socket_state_to_string(s->state),
456 prefix, socket_result_to_string(s->result),
457 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
459 prefix, s->socket_mode,
460 prefix, s->directory_mode,
461 prefix, yes_no(s->keep_alive),
462 prefix, yes_no(s->free_bind),
463 prefix, yes_no(s->transparent),
464 prefix, yes_no(s->broadcast),
465 prefix, yes_no(s->pass_cred),
466 prefix, yes_no(s->pass_sec),
467 prefix, strna(s->tcp_congestion));
469 if (s->control_pid > 0)
471 "%sControl PID: "PID_FMT"\n",
472 prefix, s->control_pid);
474 if (s->bind_to_device)
476 "%sBindToDevice: %s\n",
477 prefix, s->bind_to_device);
482 "%sNConnections: %u\n"
483 "%sMaxConnections: %u\n",
484 prefix, s->n_accepted,
485 prefix, s->n_connections,
486 prefix, s->max_connections);
488 if (s->priority >= 0)
491 prefix, s->priority);
493 if (s->receive_buffer > 0)
495 "%sReceiveBuffer: %zu\n",
496 prefix, s->receive_buffer);
498 if (s->send_buffer > 0)
500 "%sSendBuffer: %zu\n",
501 prefix, s->send_buffer);
513 if (s->pipe_size > 0)
516 prefix, s->pipe_size);
523 if (s->mq_maxmsg > 0)
525 "%sMessageQueueMaxMessages: %li\n",
526 prefix, s->mq_maxmsg);
528 if (s->mq_msgsize > 0)
530 "%sMessageQueueMessageSize: %li\n",
531 prefix, s->mq_msgsize);
536 prefix, yes_no(s->reuse_port));
540 "%sSmackLabel: %s\n",
545 "%sSmackLabelIPIn: %s\n",
546 prefix, s->smack_ip_in);
550 "%sSmackLabelIPOut: %s\n",
551 prefix, s->smack_ip_out);
553 LIST_FOREACH(port, p, s->ports) {
555 if (p->type == SOCKET_SOCKET) {
560 if ((r = socket_address_print(&p->address, &k)) < 0)
565 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
567 } else if (p->type == SOCKET_SPECIAL)
568 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
569 else if (p->type == SOCKET_MQUEUE)
570 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
572 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
575 exec_context_dump(&s->exec_context, f, prefix);
576 kill_context_dump(&s->kill_context, f, prefix);
578 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
579 if (!s->exec_command[c])
582 fprintf(f, "%s-> %s:\n",
583 prefix, socket_exec_command_to_string(c));
585 exec_command_dump_list(s->exec_command[c], f, prefix2);
589 static int instance_from_socket(int fd, unsigned nr, char **instance) {
592 union sockaddr_union local, remote;
598 if (getsockname(fd, &local.sa, &l) < 0)
602 if (getpeername(fd, &remote.sa, &l) < 0)
605 switch (local.sa.sa_family) {
609 a = ntohl(local.in.sin_addr.s_addr),
610 b = ntohl(remote.in.sin_addr.s_addr);
613 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
615 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
616 ntohs(local.in.sin_port),
617 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
618 ntohs(remote.in.sin_port)) < 0)
625 static const unsigned char ipv4_prefix[] = {
626 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
629 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
630 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
632 *a = local.in6.sin6_addr.s6_addr+12,
633 *b = remote.in6.sin6_addr.s6_addr+12;
636 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
638 a[0], a[1], a[2], a[3],
639 ntohs(local.in6.sin6_port),
640 b[0], b[1], b[2], b[3],
641 ntohs(remote.in6.sin6_port)) < 0)
644 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
649 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
650 ntohs(local.in6.sin6_port),
651 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
652 ntohs(remote.in6.sin6_port)) < 0)
663 k = getpeercred(fd, &ucred);
666 "%u-"PID_FMT"-"UID_FMT,
667 nr, ucred.pid, ucred.uid) < 0)
669 } else if (k == -ENODATA) {
670 /* This handles the case where somebody is
671 * connecting from another pid/uid namespace
672 * (e.g. from outside of our container). */
684 assert_not_reached("Unhandled socket type.");
691 static void socket_close_fds(Socket *s) {
696 LIST_FOREACH(port, p, s->ports) {
698 p->event_source = sd_event_source_unref(p->event_source);
703 p->fd = safe_close(p->fd);
705 /* One little note: we should never delete any sockets
706 * in the file system here! After all some other
707 * process we spawned might still have a reference of
708 * this fd and wants to continue to use it. Therefore
709 * we delete sockets in the file system before we
710 * create a new one, not after we stopped using
715 static void socket_apply_socket_options(Socket *s, int fd) {
720 int b = s->keep_alive;
721 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
722 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
727 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
728 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
733 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
734 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
739 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
740 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
743 if (s->priority >= 0)
744 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
745 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
747 if (s->receive_buffer > 0) {
748 int value = (int) s->receive_buffer;
750 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
752 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
753 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
754 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
757 if (s->send_buffer > 0) {
758 int value = (int) s->send_buffer;
759 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
760 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
761 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
765 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
766 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
769 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
770 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
772 if (s->ip_ttl >= 0) {
775 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
777 if (socket_ipv6_is_supported())
778 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
781 errno = EAFNOSUPPORT;
785 log_warning_unit(UNIT(s)->id,
786 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
789 if (s->tcp_congestion)
790 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
791 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
794 int b = s->reuse_port;
795 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)) < 0)
796 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
800 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
801 log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
804 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
805 log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
808 static void socket_apply_fifo_options(Socket *s, int fd) {
812 if (s->pipe_size > 0)
813 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
814 log_warning_unit(UNIT(s)->id,
818 if (smack_label_fd(fd, s->smack) < 0)
819 log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
822 static int fifo_address_create(
824 mode_t directory_mode,
835 mkdir_parents_label(path, directory_mode);
837 r = label_context_set(path, S_IFIFO);
841 /* Enforce the right access mode for the fifo */
842 old_mask = umask(~ socket_mode);
844 /* Include the original umask in our mask */
845 umask(~socket_mode | old_mask);
847 r = mkfifo(path, socket_mode);
850 if (r < 0 && errno != EEXIST) {
855 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
860 label_context_clear();
862 if (fstat(fd, &st) < 0) {
867 if (!S_ISFIFO(st.st_mode) ||
868 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
869 st.st_uid != getuid() ||
870 st.st_gid != getgid()) {
880 label_context_clear();
886 static int special_address_create(
896 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
901 if (fstat(fd, &st) < 0) {
906 /* Check whether this is a /proc, /sys or /dev file or char device */
907 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
921 static int mq_address_create(
931 struct mq_attr _attr, *attr = NULL;
936 if (maxmsg > 0 && msgsize > 0) {
938 _attr.mq_flags = O_NONBLOCK;
939 _attr.mq_maxmsg = maxmsg;
940 _attr.mq_msgsize = msgsize;
944 /* Enforce the right access mode for the mq */
945 old_mask = umask(~ mq_mode);
947 /* Include the original umask in our mask */
948 umask(~mq_mode | old_mask);
950 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
958 if (fstat(fd, &st) < 0) {
963 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
964 st.st_uid != getuid() ||
965 st.st_gid != getgid()) {
979 static int socket_open_fds(Socket *s) {
983 bool know_label = false;
987 LIST_FOREACH(port, p, s->ports) {
992 if (p->type == SOCKET_SOCKET) {
996 if ((r = socket_instantiate_service(s)) < 0)
999 if (UNIT_ISSET(s->service) &&
1000 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1001 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1012 r = socket_address_listen(
1014 SOCK_CLOEXEC|SOCK_NONBLOCK,
1027 socket_apply_socket_options(s, p->fd);
1029 } else if (p->type == SOCKET_SPECIAL) {
1031 r = special_address_create(
1037 } else if (p->type == SOCKET_FIFO) {
1039 r = fifo_address_create(
1047 socket_apply_fifo_options(s, p->fd);
1048 } else if (p->type == SOCKET_MQUEUE) {
1050 r = mq_address_create(
1059 assert_not_reached("Unknown port type");
1066 socket_close_fds(s);
1071 static void socket_unwatch_fds(Socket *s) {
1077 LIST_FOREACH(port, p, s->ports) {
1081 if (p->event_source) {
1082 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_OFF);
1084 log_debug_unit(UNIT(s)->id, "Failed to disable event source.");
1089 static int socket_watch_fds(Socket *s) {
1095 LIST_FOREACH(port, p, s->ports) {
1099 if (p->event_source)
1100 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1102 r = sd_event_add_io(UNIT(s)->manager->event, &p->event_source, p->fd, EPOLLIN, socket_dispatch_io, p);
1105 log_warning_unit(UNIT(s)->id, "Failed to watch listening fds: %s", strerror(-r));
1113 socket_unwatch_fds(s);
1117 static void socket_set_state(Socket *s, SocketState state) {
1118 SocketState old_state;
1121 old_state = s->state;
1124 if (state != SOCKET_START_PRE &&
1125 state != SOCKET_START_POST &&
1126 state != SOCKET_STOP_PRE &&
1127 state != SOCKET_STOP_PRE_SIGTERM &&
1128 state != SOCKET_STOP_PRE_SIGKILL &&
1129 state != SOCKET_STOP_POST &&
1130 state != SOCKET_FINAL_SIGTERM &&
1131 state != SOCKET_FINAL_SIGKILL) {
1133 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1134 socket_unwatch_control_pid(s);
1135 s->control_command = NULL;
1136 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1139 if (state != SOCKET_LISTENING)
1140 socket_unwatch_fds(s);
1142 if (state != SOCKET_START_POST &&
1143 state != SOCKET_LISTENING &&
1144 state != SOCKET_RUNNING &&
1145 state != SOCKET_STOP_PRE &&
1146 state != SOCKET_STOP_PRE_SIGTERM &&
1147 state != SOCKET_STOP_PRE_SIGKILL)
1148 socket_close_fds(s);
1150 if (state != old_state)
1151 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s",
1152 UNIT(s)->id, socket_state_to_string(old_state), socket_state_to_string(state));
1154 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1157 static int socket_coldplug(Unit *u) {
1158 Socket *s = SOCKET(u);
1162 assert(s->state == SOCKET_DEAD);
1164 if (s->deserialized_state == s->state)
1167 if (s->deserialized_state == SOCKET_START_PRE ||
1168 s->deserialized_state == SOCKET_START_POST ||
1169 s->deserialized_state == SOCKET_STOP_PRE ||
1170 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1171 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1172 s->deserialized_state == SOCKET_STOP_POST ||
1173 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1174 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1176 if (s->control_pid <= 0)
1179 r = unit_watch_pid(UNIT(s), s->control_pid);
1183 r = socket_arm_timer(s);
1188 if (s->deserialized_state == SOCKET_START_POST ||
1189 s->deserialized_state == SOCKET_LISTENING ||
1190 s->deserialized_state == SOCKET_RUNNING ||
1191 s->deserialized_state == SOCKET_STOP_PRE ||
1192 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1193 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL) {
1194 r = socket_open_fds(s);
1199 if (s->deserialized_state == SOCKET_LISTENING) {
1200 r = socket_watch_fds(s);
1205 socket_set_state(s, s->deserialized_state);
1209 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1218 unit_realize_cgroup(UNIT(s));
1220 r = unit_setup_exec_runtime(UNIT(s));
1224 r = socket_arm_timer(s);
1228 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1236 UNIT(s)->manager->environment,
1240 UNIT(s)->manager->confirm_spawn,
1241 UNIT(s)->manager->cgroup_supported,
1242 UNIT(s)->cgroup_path,
1243 manager_get_runtime_prefix(UNIT(s)->manager),
1254 r = unit_watch_pid(UNIT(s), pid);
1256 /* FIXME: we need to do something here */
1264 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1269 static void socket_enter_dead(Socket *s, SocketResult f) {
1272 if (f != SOCKET_SUCCESS)
1275 exec_runtime_destroy(s->exec_runtime);
1276 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1278 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1280 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1283 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1285 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1289 if (f != SOCKET_SUCCESS)
1292 socket_unwatch_control_pid(s);
1294 s->control_command_id = SOCKET_EXEC_STOP_POST;
1296 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1297 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1300 socket_set_state(s, SOCKET_STOP_POST);
1302 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1307 log_warning_unit(UNIT(s)->id,
1308 "%s failed to run 'stop-post' task: %s",
1309 UNIT(s)->id, strerror(-r));
1310 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1313 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1318 if (f != SOCKET_SUCCESS)
1321 r = unit_kill_context(
1324 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1332 r = socket_arm_timer(s);
1336 socket_set_state(s, state);
1337 } else if (state == SOCKET_STOP_PRE_SIGTERM)
1338 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_SUCCESS);
1339 else if (state == SOCKET_STOP_PRE_SIGKILL)
1340 socket_enter_stop_post(s, SOCKET_SUCCESS);
1341 else if (state == SOCKET_FINAL_SIGTERM)
1342 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
1344 socket_enter_dead(s, SOCKET_SUCCESS);
1349 log_warning_unit(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1351 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1352 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1354 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1357 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1361 if (f != SOCKET_SUCCESS)
1364 socket_unwatch_control_pid(s);
1366 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1368 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1369 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1372 socket_set_state(s, SOCKET_STOP_PRE);
1374 socket_enter_stop_post(s, SOCKET_SUCCESS);
1379 log_warning_unit(UNIT(s)->id, "%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1380 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1383 static void socket_enter_listening(Socket *s) {
1387 r = socket_watch_fds(s);
1389 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1393 socket_set_state(s, SOCKET_LISTENING);
1397 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1400 static void socket_enter_start_post(Socket *s) {
1404 r = socket_open_fds(s);
1406 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1410 socket_unwatch_control_pid(s);
1412 s->control_command_id = SOCKET_EXEC_START_POST;
1414 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1415 r = socket_spawn(s, s->control_command, &s->control_pid);
1417 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1421 socket_set_state(s, SOCKET_START_POST);
1423 socket_enter_listening(s);
1428 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1431 static void socket_enter_start_pre(Socket *s) {
1435 socket_unwatch_control_pid(s);
1437 s->control_command_id = SOCKET_EXEC_START_PRE;
1439 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1440 r = socket_spawn(s, s->control_command, &s->control_pid);
1444 socket_set_state(s, SOCKET_START_PRE);
1446 socket_enter_start_post(s);
1451 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1452 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1455 static void socket_enter_running(Socket *s, int cfd) {
1456 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1461 /* We don't take connections anymore if we are supposed to
1462 * shut down anyway */
1463 if (unit_stop_pending(UNIT(s))) {
1465 log_debug_unit(UNIT(s)->id, "Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1470 /* Flush all sockets by closing and reopening them */
1471 socket_close_fds(s);
1473 r = socket_open_fds(s);
1475 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1476 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1480 r = socket_watch_fds(s);
1482 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1483 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1493 bool pending = false;
1495 /* If there's already a start pending don't bother to
1497 SET_FOREACH(other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1498 if (unit_active_or_pending(other)) {
1504 if (!UNIT_ISSET(s->service)) {
1505 log_error_unit(UNIT(s)->id, "%s: service to activate vanished, refusing activation.", UNIT(s)->id);
1510 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1515 socket_set_state(s, SOCKET_RUNNING);
1517 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1520 if (s->n_connections >= s->max_connections) {
1521 log_warning_unit(UNIT(s)->id, "%s: Too many incoming connections (%u)", UNIT(s)->id, s->n_connections);
1526 r = socket_instantiate_service(s);
1530 r = instance_from_socket(cfd, s->n_accepted, &instance);
1535 /* ENOTCONN is legitimate if TCP RST was received.
1536 * This connection is over, but the socket unit lives on. */
1541 prefix = unit_name_to_prefix(UNIT(s)->id);
1547 name = unit_name_build(prefix, instance, ".service");
1553 r = unit_add_name(UNIT_DEREF(s->service), name);
1557 service = SERVICE(UNIT_DEREF(s->service));
1558 unit_ref_unset(&s->service);
1561 UNIT(service)->no_gc = false;
1563 unit_choose_id(UNIT(service), name);
1565 r = service_set_socket_fd(service, cfd, s);
1570 s->n_connections ++;
1572 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1576 /* Notify clients about changed counters */
1577 unit_add_to_dbus_queue(UNIT(s));
1583 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",
1584 UNIT(s)->id, cfd >= 0 ? "template" : "non-template",
1585 bus_error_message(&error, r));
1587 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1591 static void socket_run_next(Socket *s) {
1595 assert(s->control_command);
1596 assert(s->control_command->command_next);
1598 socket_unwatch_control_pid(s);
1600 s->control_command = s->control_command->command_next;
1602 r = socket_spawn(s, s->control_command, &s->control_pid);
1609 log_warning_unit(UNIT(s)->id, "%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1611 if (s->state == SOCKET_START_POST)
1612 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1613 else if (s->state == SOCKET_STOP_POST)
1614 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1616 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1619 static int socket_start(Unit *u) {
1620 Socket *s = SOCKET(u);
1624 /* We cannot fulfill this request right now, try again later
1626 if (s->state == SOCKET_STOP_PRE ||
1627 s->state == SOCKET_STOP_PRE_SIGKILL ||
1628 s->state == SOCKET_STOP_PRE_SIGTERM ||
1629 s->state == SOCKET_STOP_POST ||
1630 s->state == SOCKET_FINAL_SIGTERM ||
1631 s->state == SOCKET_FINAL_SIGKILL)
1634 if (s->state == SOCKET_START_PRE ||
1635 s->state == SOCKET_START_POST)
1638 /* Cannot run this without the service being around */
1639 if (UNIT_ISSET(s->service)) {
1642 service = SERVICE(UNIT_DEREF(s->service));
1644 if (UNIT(service)->load_state != UNIT_LOADED) {
1645 log_error_unit(u->id, "Socket service %s not loaded, refusing.", UNIT(service)->id);
1649 /* If the service is already active we cannot start the
1651 if (service->state != SERVICE_DEAD &&
1652 service->state != SERVICE_FAILED &&
1653 service->state != SERVICE_AUTO_RESTART) {
1654 log_error_unit(u->id, "Socket service %s already active, refusing.", UNIT(service)->id);
1658 #ifdef HAVE_SYSV_COMPAT
1659 if (service->is_sysv) {
1660 log_error_unit(u->id,
1661 "Using SysV services for socket activation is not supported. Refusing.");
1667 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1669 s->result = SOCKET_SUCCESS;
1670 socket_enter_start_pre(s);
1675 static int socket_stop(Unit *u) {
1676 Socket *s = SOCKET(u);
1681 if (s->state == SOCKET_STOP_PRE ||
1682 s->state == SOCKET_STOP_PRE_SIGTERM ||
1683 s->state == SOCKET_STOP_PRE_SIGKILL ||
1684 s->state == SOCKET_STOP_POST ||
1685 s->state == SOCKET_FINAL_SIGTERM ||
1686 s->state == SOCKET_FINAL_SIGKILL)
1689 /* If there's already something running we go directly into
1691 if (s->state == SOCKET_START_PRE ||
1692 s->state == SOCKET_START_POST) {
1693 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1697 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1699 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1703 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1704 Socket *s = SOCKET(u);
1712 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1713 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1714 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1716 if (s->control_pid > 0)
1717 unit_serialize_item_format(u, f, "control-pid", PID_FMT, s->control_pid);
1719 if (s->control_command_id >= 0)
1720 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1722 LIST_FOREACH(port, p, s->ports) {
1728 copy = fdset_put_dup(fds, p->fd);
1732 if (p->type == SOCKET_SOCKET) {
1733 _cleanup_free_ char *t = NULL;
1735 r = socket_address_print(&p->address, &t);
1739 if (socket_address_family(&p->address) == AF_NETLINK)
1740 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1742 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1744 } else if (p->type == SOCKET_SPECIAL)
1745 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1746 else if (p->type == SOCKET_MQUEUE)
1747 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1749 assert(p->type == SOCKET_FIFO);
1750 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1757 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1758 Socket *s = SOCKET(u);
1764 if (streq(key, "state")) {
1767 state = socket_state_from_string(value);
1769 log_debug_unit(u->id, "Failed to parse state value %s", value);
1771 s->deserialized_state = state;
1772 } else if (streq(key, "result")) {
1775 f = socket_result_from_string(value);
1777 log_debug_unit(u->id, "Failed to parse result value %s", value);
1778 else if (f != SOCKET_SUCCESS)
1781 } else if (streq(key, "n-accepted")) {
1784 if (safe_atou(value, &k) < 0)
1785 log_debug_unit(u->id, "Failed to parse n-accepted value %s", value);
1788 } else if (streq(key, "control-pid")) {
1791 if (parse_pid(value, &pid) < 0)
1792 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1794 s->control_pid = pid;
1795 } else if (streq(key, "control-command")) {
1796 SocketExecCommand id;
1798 id = socket_exec_command_from_string(value);
1800 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1802 s->control_command_id = id;
1803 s->control_command = s->exec_command[id];
1805 } else if (streq(key, "fifo")) {
1809 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1810 log_debug_unit(u->id, "Failed to parse fifo value %s", value);
1813 LIST_FOREACH(port, p, s->ports)
1814 if (p->type == SOCKET_FIFO &&
1815 streq_ptr(p->path, value+skip))
1820 p->fd = fdset_remove(fds, fd);
1824 } else if (streq(key, "special")) {
1828 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1829 log_debug_unit(u->id, "Failed to parse special value %s", value);
1832 LIST_FOREACH(port, p, s->ports)
1833 if (p->type == SOCKET_SPECIAL &&
1834 streq_ptr(p->path, value+skip))
1839 p->fd = fdset_remove(fds, fd);
1843 } else if (streq(key, "mqueue")) {
1847 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1848 log_debug_unit(u->id, "Failed to parse mqueue value %s", value);
1851 LIST_FOREACH(port, p, s->ports)
1852 if (p->type == SOCKET_MQUEUE &&
1853 streq_ptr(p->path, value+skip))
1858 p->fd = fdset_remove(fds, fd);
1862 } else if (streq(key, "socket")) {
1863 int fd, type, skip = 0;
1866 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1867 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1870 LIST_FOREACH(port, p, s->ports)
1871 if (socket_address_is(&p->address, value+skip, type))
1876 p->fd = fdset_remove(fds, fd);
1880 } else if (streq(key, "netlink")) {
1884 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1885 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1888 LIST_FOREACH(port, p, s->ports)
1889 if (socket_address_is_netlink(&p->address, value+skip))
1894 p->fd = fdset_remove(fds, fd);
1898 log_debug_unit(UNIT(s)->id, "Unknown serialization key '%s'", key);
1903 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1904 Socket *s = SOCKET(u);
1909 LIST_FOREACH(port, p, s->ports) {
1913 if (p->type != SOCKET_SOCKET)
1919 FDSET_FOREACH(fd, fds, i) {
1920 if (socket_address_matches_fd(&p->address, fd)) {
1921 p->fd = fdset_remove(fds, fd);
1922 s->deserialized_state = SOCKET_LISTENING;
1931 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1934 return state_translation_table[SOCKET(u)->state];
1937 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1940 return socket_state_to_string(SOCKET(u)->state);
1943 const char* socket_port_type_to_string(SocketPort *p) {
1951 switch (p->address.type) {
1959 case SOCK_SEQPACKET:
1960 return "SequentialPacket";
1963 if (socket_address_family(&p->address) == AF_NETLINK)
1970 case SOCKET_SPECIAL:
1974 return "MessageQueue";
1984 _pure_ static bool socket_check_gc(Unit *u) {
1985 Socket *s = SOCKET(u);
1989 return s->n_connections > 0;
1992 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1993 SocketPort *p = userdata;
1999 if (p->socket->state != SOCKET_LISTENING)
2002 log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
2004 if (revents != EPOLLIN) {
2006 if (revents & EPOLLHUP)
2007 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.",
2008 UNIT(p->socket)->id);
2010 log_error_unit(UNIT(p->socket)->id, "%s: Got unexpected poll event (0x%x) on socket.",
2011 UNIT(p->socket)->id, revents);
2016 if (p->socket->accept &&
2017 p->type == SOCKET_SOCKET &&
2018 socket_address_can_accept(&p->address)) {
2022 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2028 log_error_unit(UNIT(p->socket)->id,
2029 "Failed to accept socket: %m");
2036 socket_apply_socket_options(p->socket, cfd);
2039 socket_enter_running(p->socket, cfd);
2043 socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2047 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2048 Socket *s = SOCKET(u);
2054 if (pid != s->control_pid)
2059 if (is_clean_exit(code, status, NULL))
2061 else if (code == CLD_EXITED)
2062 f = SOCKET_FAILURE_EXIT_CODE;
2063 else if (code == CLD_KILLED)
2064 f = SOCKET_FAILURE_SIGNAL;
2065 else if (code == CLD_DUMPED)
2066 f = SOCKET_FAILURE_CORE_DUMP;
2068 assert_not_reached("Unknown code");
2070 if (s->control_command) {
2071 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2073 if (s->control_command->ignore)
2077 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2079 "%s control process exited, code=%s status=%i",
2080 u->id, sigchld_code_to_string(code), status);
2082 if (f != SOCKET_SUCCESS)
2085 if (s->control_command &&
2086 s->control_command->command_next &&
2087 f == SOCKET_SUCCESS) {
2089 log_debug_unit(u->id,
2090 "%s running next command for state %s",
2091 u->id, socket_state_to_string(s->state));
2094 s->control_command = NULL;
2095 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2097 /* No further commands for this step, so let's figure
2098 * out what to do next */
2100 log_debug_unit(u->id,
2101 "%s got final SIGCHLD for state %s",
2102 u->id, socket_state_to_string(s->state));
2106 case SOCKET_START_PRE:
2107 if (f == SOCKET_SUCCESS)
2108 socket_enter_start_post(s);
2110 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2113 case SOCKET_START_POST:
2114 if (f == SOCKET_SUCCESS)
2115 socket_enter_listening(s);
2117 socket_enter_stop_pre(s, f);
2120 case SOCKET_STOP_PRE:
2121 case SOCKET_STOP_PRE_SIGTERM:
2122 case SOCKET_STOP_PRE_SIGKILL:
2123 socket_enter_stop_post(s, f);
2126 case SOCKET_STOP_POST:
2127 case SOCKET_FINAL_SIGTERM:
2128 case SOCKET_FINAL_SIGKILL:
2129 socket_enter_dead(s, f);
2133 assert_not_reached("Uh, control process died at wrong time.");
2137 /* Notify clients about changed exit status */
2138 unit_add_to_dbus_queue(u);
2141 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2142 Socket *s = SOCKET(userdata);
2145 assert(s->timer_event_source == source);
2149 case SOCKET_START_PRE:
2150 log_warning_unit(UNIT(s)->id,
2151 "%s starting timed out. Terminating.", UNIT(s)->id);
2152 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2155 case SOCKET_START_POST:
2156 log_warning_unit(UNIT(s)->id,
2157 "%s starting timed out. Stopping.", UNIT(s)->id);
2158 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2161 case SOCKET_STOP_PRE:
2162 log_warning_unit(UNIT(s)->id,
2163 "%s stopping timed out. Terminating.", UNIT(s)->id);
2164 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2167 case SOCKET_STOP_PRE_SIGTERM:
2168 if (s->kill_context.send_sigkill) {
2169 log_warning_unit(UNIT(s)->id,
2170 "%s stopping timed out. Killing.", UNIT(s)->id);
2171 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2173 log_warning_unit(UNIT(s)->id,
2174 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2176 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2180 case SOCKET_STOP_PRE_SIGKILL:
2181 log_warning_unit(UNIT(s)->id,
2182 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2183 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2186 case SOCKET_STOP_POST:
2187 log_warning_unit(UNIT(s)->id,
2188 "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2189 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2192 case SOCKET_FINAL_SIGTERM:
2193 if (s->kill_context.send_sigkill) {
2194 log_warning_unit(UNIT(s)->id,
2195 "%s stopping timed out (2). Killing.", UNIT(s)->id);
2196 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2198 log_warning_unit(UNIT(s)->id,
2199 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2201 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2205 case SOCKET_FINAL_SIGKILL:
2206 log_warning_unit(UNIT(s)->id,
2207 "%s still around after SIGKILL (2). Entering failed mode.",
2209 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2213 assert_not_reached("Timeout at wrong time.");
2219 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2228 /* Called from the service code for requesting our fds */
2231 LIST_FOREACH(port, p, s->ports)
2241 if (!(rfds = new(int, rn_fds)))
2245 LIST_FOREACH(port, p, s->ports)
2249 assert(k == rn_fds);
2257 static void socket_reset_failed(Unit *u) {
2258 Socket *s = SOCKET(u);
2262 if (s->state == SOCKET_FAILED)
2263 socket_set_state(s, SOCKET_DEAD);
2265 s->result = SOCKET_SUCCESS;
2268 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2271 /* The service is dead. Dang!
2273 * This is strictly for one-instance-for-all-connections
2276 if (s->state == SOCKET_RUNNING) {
2277 log_debug_unit(UNIT(s)->id, "%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2278 if (failed_permanent)
2279 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2281 socket_enter_listening(s);
2285 void socket_connection_unref(Socket *s) {
2288 /* The service is dead. Yay!
2290 * This is strictly for one-instance-per-connection
2293 assert(s->n_connections > 0);
2296 log_debug_unit(UNIT(s)->id, "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2299 static void socket_trigger_notify(Unit *u, Unit *other) {
2300 Socket *s = SOCKET(u);
2306 /* Don't propagate state changes from the service if we are
2307 already down or accepting connections */
2308 if ((s->state != SOCKET_RUNNING &&
2309 s->state != SOCKET_LISTENING) ||
2313 if (other->load_state != UNIT_LOADED ||
2314 other->type != UNIT_SERVICE)
2317 se = SERVICE(other);
2319 if (se->state == SERVICE_FAILED)
2320 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2322 if (se->state == SERVICE_DEAD ||
2323 se->state == SERVICE_STOP ||
2324 se->state == SERVICE_STOP_SIGTERM ||
2325 se->state == SERVICE_STOP_SIGKILL ||
2326 se->state == SERVICE_STOP_POST ||
2327 se->state == SERVICE_FINAL_SIGTERM ||
2328 se->state == SERVICE_FINAL_SIGKILL ||
2329 se->state == SERVICE_AUTO_RESTART)
2330 socket_notify_service_dead(s, false);
2332 if (se->state == SERVICE_RUNNING)
2333 socket_set_state(s, SOCKET_RUNNING);
2336 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2337 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2340 static int socket_get_timeout(Unit *u, uint64_t *timeout) {
2341 Socket *s = SOCKET(u);
2344 if (!s->timer_event_source)
2347 r = sd_event_source_get_time(s->timer_event_source, timeout);
2354 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2355 [SOCKET_DEAD] = "dead",
2356 [SOCKET_START_PRE] = "start-pre",
2357 [SOCKET_START_POST] = "start-post",
2358 [SOCKET_LISTENING] = "listening",
2359 [SOCKET_RUNNING] = "running",
2360 [SOCKET_STOP_PRE] = "stop-pre",
2361 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2362 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2363 [SOCKET_STOP_POST] = "stop-post",
2364 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2365 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2366 [SOCKET_FAILED] = "failed"
2369 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2371 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2372 [SOCKET_EXEC_START_PRE] = "StartPre",
2373 [SOCKET_EXEC_START_POST] = "StartPost",
2374 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2375 [SOCKET_EXEC_STOP_POST] = "StopPost"
2378 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2380 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2381 [SOCKET_SUCCESS] = "success",
2382 [SOCKET_FAILURE_RESOURCES] = "resources",
2383 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2384 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2385 [SOCKET_FAILURE_SIGNAL] = "signal",
2386 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2387 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2390 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2392 const UnitVTable socket_vtable = {
2393 .object_size = sizeof(Socket),
2394 .exec_context_offset = offsetof(Socket, exec_context),
2395 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2396 .kill_context_offset = offsetof(Socket, kill_context),
2397 .exec_runtime_offset = offsetof(Socket, exec_runtime),
2403 .private_section = "Socket",
2405 .init = socket_init,
2406 .done = socket_done,
2407 .load = socket_load,
2409 .coldplug = socket_coldplug,
2411 .dump = socket_dump,
2413 .start = socket_start,
2414 .stop = socket_stop,
2416 .kill = socket_kill,
2418 .get_timeout = socket_get_timeout,
2420 .serialize = socket_serialize,
2421 .deserialize_item = socket_deserialize_item,
2422 .distribute_fds = socket_distribute_fds,
2424 .active_state = socket_active_state,
2425 .sub_state_to_string = socket_sub_state_to_string,
2427 .check_gc = socket_check_gc,
2429 .sigchld_event = socket_sigchld_event,
2431 .trigger_notify = socket_trigger_notify,
2433 .reset_failed = socket_reset_failed,
2435 .bus_interface = "org.freedesktop.systemd1.Socket",
2436 .bus_vtable = bus_socket_vtable,
2437 .bus_set_property = bus_socket_set_property,
2438 .bus_commit_properties = bus_socket_commit_properties,
2440 .status_message_formats = {
2441 /*.starting_stopping = {
2442 [0] = "Starting socket %s...",
2443 [1] = "Stopping socket %s...",
2445 .finished_start_job = {
2446 [JOB_DONE] = "Listening on %s.",
2447 [JOB_FAILED] = "Failed to listen on %s.",
2448 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2449 [JOB_TIMEOUT] = "Timed out starting %s.",
2451 .finished_stop_job = {
2452 [JOB_DONE] = "Closed %s.",
2453 [JOB_FAILED] = "Failed stopping %s.",
2454 [JOB_TIMEOUT] = "Timed out stopping %s.",