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>
33 #include <attr/xattr.h>
38 #include "load-dropin.h"
39 #include "load-fragment.h"
42 #include "path-util.h"
43 #include "unit-name.h"
44 #include "unit-printf.h"
48 #include "exit-status.h"
50 #include "smack-util.h"
52 #include "bus-error.h"
53 #include "dbus-socket.h"
57 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
58 [SOCKET_DEAD] = UNIT_INACTIVE,
59 [SOCKET_START_PRE] = UNIT_ACTIVATING,
60 [SOCKET_START_POST] = UNIT_ACTIVATING,
61 [SOCKET_LISTENING] = UNIT_ACTIVE,
62 [SOCKET_RUNNING] = UNIT_ACTIVE,
63 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
64 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
65 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
66 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
67 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
68 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
69 [SOCKET_FAILED] = UNIT_FAILED
72 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
73 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
75 static void socket_init(Unit *u) {
76 Socket *s = SOCKET(u);
79 assert(u->load_state == UNIT_STUB);
81 s->backlog = SOMAXCONN;
82 s->timeout_usec = u->manager->default_timeout_start_usec;
83 s->directory_mode = 0755;
84 s->socket_mode = 0666;
86 s->max_connections = 64;
93 exec_context_init(&s->exec_context);
94 s->exec_context.std_output = u->manager->default_std_output;
95 s->exec_context.std_error = u->manager->default_std_error;
96 kill_context_init(&s->kill_context);
97 cgroup_context_init(&s->cgroup_context);
99 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
102 static void socket_unwatch_control_pid(Socket *s) {
105 if (s->control_pid <= 0)
108 unit_unwatch_pid(UNIT(s), s->control_pid);
112 void socket_free_ports(Socket *s) {
117 while ((p = s->ports)) {
118 LIST_REMOVE(port, s->ports, p);
120 sd_event_source_unref(p->event_source);
123 close_nointr_nofail(p->fd);
130 static void socket_done(Unit *u) {
131 Socket *s = SOCKET(u);
135 socket_free_ports(s);
137 cgroup_context_done(&s->cgroup_context);
138 exec_context_done(&s->exec_context);
139 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
140 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
141 s->control_command = NULL;
143 socket_unwatch_control_pid(s);
145 unit_ref_unset(&s->service);
147 free(s->tcp_congestion);
148 s->tcp_congestion = NULL;
150 free(s->bind_to_device);
151 s->bind_to_device = NULL;
154 free(s->smack_ip_in);
155 free(s->smack_ip_out);
157 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
160 static int socket_arm_timer(Socket *s) {
165 if (s->timeout_usec <= 0) {
166 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
170 if (s->timer_event_source) {
171 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec);
175 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
178 return sd_event_add_monotonic(UNIT(s)->manager->event, now(CLOCK_MONOTONIC) + s->timeout_usec, 0, socket_dispatch_timer, s, &s->timer_event_source);
181 static int socket_instantiate_service(Socket *s) {
188 /* This fills in s->service if it isn't filled in yet. For
189 * Accept=yes sockets we create the next connection service
190 * here. For Accept=no this is mostly a NOP since the service
191 * is figured out at load time anyway. */
193 if (UNIT_DEREF(s->service))
198 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
201 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
207 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
213 #ifdef HAVE_SYSV_COMPAT
214 if (SERVICE(u)->is_sysv) {
215 log_error("Using SysV services for socket activation is not supported. Refusing.");
221 unit_ref_set(&s->service, u);
223 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
226 static bool have_non_accept_socket(Socket *s) {
234 LIST_FOREACH(port, p, s->ports) {
236 if (p->type != SOCKET_SOCKET)
239 if (!socket_address_can_accept(&p->address))
246 static int socket_add_mount_links(Socket *s) {
252 LIST_FOREACH(port, p, s->ports) {
253 const char *path = NULL;
255 if (p->type == SOCKET_SOCKET)
256 path = socket_address_get_path(&p->address);
257 else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL)
263 r = unit_require_mounts_for(UNIT(s), path);
271 static int socket_add_device_link(Socket *s) {
276 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
279 t = strappenda("/sys/subsystem/net/devices/", s->bind_to_device);
280 return unit_add_node_link(UNIT(s), t, false);
283 static int socket_add_default_dependencies(Socket *s) {
287 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
291 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
292 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
297 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
300 _pure_ static bool socket_has_exec(Socket *s) {
304 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
305 if (s->exec_command[i])
311 static int socket_add_extras(Socket *s) {
317 if (have_non_accept_socket(s)) {
319 if (!UNIT_DEREF(s->service)) {
322 r = unit_load_related_unit(u, ".service", &x);
326 unit_ref_set(&s->service, x);
329 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
334 r = socket_add_mount_links(s);
338 r = socket_add_device_link(s);
342 r = unit_exec_context_defaults(u, &s->exec_context);
346 if (socket_has_exec(s)) {
347 r = unit_add_exec_dependencies(u, &s->exec_context);
351 r = unit_add_default_slice(u);
356 if (u->default_dependencies) {
357 r = socket_add_default_dependencies(s);
365 static int socket_verify(Socket *s) {
368 if (UNIT(s)->load_state != UNIT_LOADED)
372 log_error_unit(UNIT(s)->id, "%s lacks Listen setting. Refusing.", UNIT(s)->id);
376 if (s->accept && have_non_accept_socket(s)) {
377 log_error_unit(UNIT(s)->id, "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
382 if (s->accept && s->max_connections <= 0) {
383 log_error_unit(UNIT(s)->id, "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
387 if (s->accept && UNIT_DEREF(s->service)) {
388 log_error_unit(UNIT(s)->id, "Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
392 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
393 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
400 static int socket_load(Unit *u) {
401 Socket *s = SOCKET(u);
405 assert(u->load_state == UNIT_STUB);
407 r = unit_load_fragment_and_dropin(u);
411 if (u->load_state == UNIT_LOADED) {
412 /* This is a new unit? Then let's add in some extras */
413 r = socket_add_extras(s);
418 return socket_verify(s);
421 _const_ static const char* listen_lookup(int family, int type) {
423 if (family == AF_NETLINK)
424 return "ListenNetlink";
426 if (type == SOCK_STREAM)
427 return "ListenStream";
428 else if (type == SOCK_DGRAM)
429 return "ListenDatagram";
430 else if (type == SOCK_SEQPACKET)
431 return "ListenSequentialPacket";
433 assert_not_reached("Unknown socket type");
437 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
439 Socket *s = SOCKET(u);
446 prefix2 = strappenda(prefix, "\t");
449 "%sSocket State: %s\n"
451 "%sBindIPv6Only: %s\n"
453 "%sSocketMode: %04o\n"
454 "%sDirectoryMode: %04o\n"
457 "%sTransparent: %s\n"
459 "%sPassCredentials: %s\n"
460 "%sPassSecurity: %s\n"
461 "%sTCPCongestion: %s\n",
462 prefix, socket_state_to_string(s->state),
463 prefix, socket_result_to_string(s->result),
464 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
466 prefix, s->socket_mode,
467 prefix, s->directory_mode,
468 prefix, yes_no(s->keep_alive),
469 prefix, yes_no(s->free_bind),
470 prefix, yes_no(s->transparent),
471 prefix, yes_no(s->broadcast),
472 prefix, yes_no(s->pass_cred),
473 prefix, yes_no(s->pass_sec),
474 prefix, strna(s->tcp_congestion));
476 if (s->control_pid > 0)
478 "%sControl PID: %lu\n",
479 prefix, (unsigned long) s->control_pid);
481 if (s->bind_to_device)
483 "%sBindToDevice: %s\n",
484 prefix, s->bind_to_device);
489 "%sNConnections: %u\n"
490 "%sMaxConnections: %u\n",
491 prefix, s->n_accepted,
492 prefix, s->n_connections,
493 prefix, s->max_connections);
495 if (s->priority >= 0)
498 prefix, s->priority);
500 if (s->receive_buffer > 0)
502 "%sReceiveBuffer: %zu\n",
503 prefix, s->receive_buffer);
505 if (s->send_buffer > 0)
507 "%sSendBuffer: %zu\n",
508 prefix, s->send_buffer);
520 if (s->pipe_size > 0)
523 prefix, s->pipe_size);
530 if (s->mq_maxmsg > 0)
532 "%sMessageQueueMaxMessages: %li\n",
533 prefix, s->mq_maxmsg);
535 if (s->mq_msgsize > 0)
537 "%sMessageQueueMessageSize: %li\n",
538 prefix, s->mq_msgsize);
543 prefix, yes_no(s->reuse_port));
547 "%sSmackLabel: %s\n",
552 "%sSmackLabelIPIn: %s\n",
553 prefix, s->smack_ip_in);
557 "%sSmackLabelIPOut: %s\n",
558 prefix, s->smack_ip_out);
560 LIST_FOREACH(port, p, s->ports) {
562 if (p->type == SOCKET_SOCKET) {
567 if ((r = socket_address_print(&p->address, &k)) < 0)
572 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
574 } else if (p->type == SOCKET_SPECIAL)
575 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
576 else if (p->type == SOCKET_MQUEUE)
577 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
579 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
582 exec_context_dump(&s->exec_context, f, prefix);
583 kill_context_dump(&s->kill_context, f, prefix);
585 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
586 if (!s->exec_command[c])
589 fprintf(f, "%s-> %s:\n",
590 prefix, socket_exec_command_to_string(c));
592 exec_command_dump_list(s->exec_command[c], f, prefix2);
596 static int instance_from_socket(int fd, unsigned nr, char **instance) {
601 struct sockaddr_un un;
602 struct sockaddr_in in;
603 struct sockaddr_in6 in6;
604 struct sockaddr_storage storage;
611 if (getsockname(fd, &local.sa, &l) < 0)
615 if (getpeername(fd, &remote.sa, &l) < 0)
618 switch (local.sa.sa_family) {
622 a = ntohl(local.in.sin_addr.s_addr),
623 b = ntohl(remote.in.sin_addr.s_addr);
626 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
628 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
629 ntohs(local.in.sin_port),
630 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
631 ntohs(remote.in.sin_port)) < 0)
638 static const unsigned char ipv4_prefix[] = {
639 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
642 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
643 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
645 *a = local.in6.sin6_addr.s6_addr+12,
646 *b = remote.in6.sin6_addr.s6_addr+12;
649 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
651 a[0], a[1], a[2], a[3],
652 ntohs(local.in6.sin6_port),
653 b[0], b[1], b[2], b[3],
654 ntohs(remote.in6.sin6_port)) < 0)
657 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
662 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
663 ntohs(local.in6.sin6_port),
664 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
665 ntohs(remote.in6.sin6_port)) < 0)
676 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
682 (unsigned long) ucred.pid,
683 (unsigned long) ucred.uid) < 0)
690 assert_not_reached("Unhandled socket type.");
697 static void socket_close_fds(Socket *s) {
702 LIST_FOREACH(port, p, s->ports) {
704 p->event_source = sd_event_source_unref(p->event_source);
709 close_nointr_nofail(p->fd);
711 /* One little note: we should never delete any sockets
712 * in the file system here! After all some other
713 * process we spawned might still have a reference of
714 * this fd and wants to continue to use it. Therefore
715 * we delete sockets in the file system before we
716 * create a new one, not after we stopped using
723 static void socket_apply_socket_options(Socket *s, int fd) {
728 int b = s->keep_alive;
729 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
730 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
735 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
736 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
741 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
742 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
747 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
748 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
751 if (s->priority >= 0)
752 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
753 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
755 if (s->receive_buffer > 0) {
756 int value = (int) s->receive_buffer;
758 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
760 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
761 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
762 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
765 if (s->send_buffer > 0) {
766 int value = (int) s->send_buffer;
767 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
768 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
769 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
773 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
774 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
777 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
778 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
780 if (s->ip_ttl >= 0) {
783 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
785 if (socket_ipv6_is_supported())
786 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
789 errno = EAFNOSUPPORT;
793 log_warning_unit(UNIT(s)->id,
794 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
797 if (s->tcp_congestion)
798 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
799 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
802 int b = s->reuse_port;
803 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)) < 0)
804 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
808 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
809 log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
812 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
813 log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
816 static void socket_apply_fifo_options(Socket *s, int fd) {
820 if (s->pipe_size > 0)
821 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
822 log_warning_unit(UNIT(s)->id,
826 if (smack_label_fd(fd, s->smack) < 0)
827 log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
830 static int fifo_address_create(
832 mode_t directory_mode,
843 mkdir_parents_label(path, directory_mode);
845 r = label_context_set(path, S_IFIFO);
849 /* Enforce the right access mode for the fifo */
850 old_mask = umask(~ socket_mode);
852 /* Include the original umask in our mask */
853 umask(~socket_mode | old_mask);
855 r = mkfifo(path, socket_mode);
858 if (r < 0 && errno != EEXIST) {
863 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
868 label_context_clear();
870 if (fstat(fd, &st) < 0) {
875 if (!S_ISFIFO(st.st_mode) ||
876 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
877 st.st_uid != getuid() ||
878 st.st_gid != getgid()) {
888 label_context_clear();
891 close_nointr_nofail(fd);
896 static int special_address_create(
906 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
911 if (fstat(fd, &st) < 0) {
916 /* Check whether this is a /proc, /sys or /dev file or char device */
917 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
927 close_nointr_nofail(fd);
932 static int mq_address_create(
942 struct mq_attr _attr, *attr = NULL;
947 if (maxmsg > 0 && msgsize > 0) {
949 _attr.mq_flags = O_NONBLOCK;
950 _attr.mq_maxmsg = maxmsg;
951 _attr.mq_msgsize = msgsize;
955 /* Enforce the right access mode for the mq */
956 old_mask = umask(~ mq_mode);
958 /* Include the original umask in our mask */
959 umask(~mq_mode | old_mask);
961 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
969 if (fstat(fd, &st) < 0) {
974 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
975 st.st_uid != getuid() ||
976 st.st_gid != getgid()) {
987 close_nointr_nofail(fd);
992 static int socket_open_fds(Socket *s) {
996 bool know_label = false;
1000 LIST_FOREACH(port, p, s->ports) {
1005 if (p->type == SOCKET_SOCKET) {
1009 if ((r = socket_instantiate_service(s)) < 0)
1012 if (UNIT_ISSET(s->service) &&
1013 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1014 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1025 r = socket_address_listen(
1027 SOCK_CLOEXEC|SOCK_NONBLOCK,
1040 socket_apply_socket_options(s, p->fd);
1042 } else if (p->type == SOCKET_SPECIAL) {
1044 r = special_address_create(
1050 } else if (p->type == SOCKET_FIFO) {
1052 r = fifo_address_create(
1060 socket_apply_fifo_options(s, p->fd);
1061 } else if (p->type == SOCKET_MQUEUE) {
1063 r = mq_address_create(
1072 assert_not_reached("Unknown port type");
1079 socket_close_fds(s);
1084 static void socket_unwatch_fds(Socket *s) {
1090 LIST_FOREACH(port, p, s->ports) {
1094 if (p->event_source) {
1095 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_OFF);
1097 log_debug_unit(UNIT(s)->id, "Failed to disable event source.");
1102 static int socket_watch_fds(Socket *s) {
1108 LIST_FOREACH(port, p, s->ports) {
1112 if (p->event_source)
1113 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1115 r = sd_event_add_io(UNIT(s)->manager->event, p->fd, EPOLLIN, socket_dispatch_io, p, &p->event_source);
1118 log_warning_unit(UNIT(s)->id, "Failed to watch listening fds: %s", strerror(-r));
1126 socket_unwatch_fds(s);
1130 static void socket_set_state(Socket *s, SocketState state) {
1131 SocketState old_state;
1134 old_state = s->state;
1137 if (state != SOCKET_START_PRE &&
1138 state != SOCKET_START_POST &&
1139 state != SOCKET_STOP_PRE &&
1140 state != SOCKET_STOP_PRE_SIGTERM &&
1141 state != SOCKET_STOP_PRE_SIGKILL &&
1142 state != SOCKET_STOP_POST &&
1143 state != SOCKET_FINAL_SIGTERM &&
1144 state != SOCKET_FINAL_SIGKILL) {
1146 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1147 socket_unwatch_control_pid(s);
1148 s->control_command = NULL;
1149 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1152 if (state != SOCKET_LISTENING)
1153 socket_unwatch_fds(s);
1155 if (state != SOCKET_START_POST &&
1156 state != SOCKET_LISTENING &&
1157 state != SOCKET_RUNNING &&
1158 state != SOCKET_STOP_PRE &&
1159 state != SOCKET_STOP_PRE_SIGTERM &&
1160 state != SOCKET_STOP_PRE_SIGKILL)
1161 socket_close_fds(s);
1163 if (state != old_state)
1164 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s",
1165 UNIT(s)->id, socket_state_to_string(old_state), socket_state_to_string(state));
1167 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1170 static int socket_coldplug(Unit *u) {
1171 Socket *s = SOCKET(u);
1175 assert(s->state == SOCKET_DEAD);
1177 if (s->deserialized_state == s->state)
1180 if (s->deserialized_state == SOCKET_START_PRE ||
1181 s->deserialized_state == SOCKET_START_POST ||
1182 s->deserialized_state == SOCKET_STOP_PRE ||
1183 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1184 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1185 s->deserialized_state == SOCKET_STOP_POST ||
1186 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1187 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1189 if (s->control_pid <= 0)
1192 r = unit_watch_pid(UNIT(s), s->control_pid);
1196 r = socket_arm_timer(s);
1201 if (s->deserialized_state == SOCKET_START_POST ||
1202 s->deserialized_state == SOCKET_LISTENING ||
1203 s->deserialized_state == SOCKET_RUNNING ||
1204 s->deserialized_state == SOCKET_STOP_PRE ||
1205 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1206 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL) {
1207 r = socket_open_fds(s);
1212 if (s->deserialized_state == SOCKET_LISTENING) {
1213 r = socket_watch_fds(s);
1218 socket_set_state(s, s->deserialized_state);
1222 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1231 unit_realize_cgroup(UNIT(s));
1233 r = unit_setup_exec_runtime(UNIT(s));
1237 r = socket_arm_timer(s);
1241 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1249 UNIT(s)->manager->environment,
1253 UNIT(s)->manager->confirm_spawn,
1254 UNIT(s)->manager->cgroup_supported,
1255 UNIT(s)->cgroup_path,
1265 r = unit_watch_pid(UNIT(s), pid);
1267 /* FIXME: we need to do something here */
1275 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1280 static void socket_enter_dead(Socket *s, SocketResult f) {
1283 if (f != SOCKET_SUCCESS)
1286 exec_runtime_destroy(s->exec_runtime);
1287 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1289 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1292 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1294 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1298 if (f != SOCKET_SUCCESS)
1301 socket_unwatch_control_pid(s);
1303 s->control_command_id = SOCKET_EXEC_STOP_POST;
1305 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1306 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1309 socket_set_state(s, SOCKET_STOP_POST);
1311 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1316 log_warning_unit(UNIT(s)->id,
1317 "%s failed to run 'stop-post' task: %s",
1318 UNIT(s)->id, strerror(-r));
1319 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1322 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1327 if (f != SOCKET_SUCCESS)
1330 r = unit_kill_context(
1333 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1341 r = socket_arm_timer(s);
1345 socket_set_state(s, state);
1346 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1347 socket_enter_stop_post(s, SOCKET_SUCCESS);
1349 socket_enter_dead(s, SOCKET_SUCCESS);
1354 log_warning_unit(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1356 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1357 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1359 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1362 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1366 if (f != SOCKET_SUCCESS)
1369 socket_unwatch_control_pid(s);
1371 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1373 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1374 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1377 socket_set_state(s, SOCKET_STOP_PRE);
1379 socket_enter_stop_post(s, SOCKET_SUCCESS);
1384 log_warning_unit(UNIT(s)->id, "%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1385 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1388 static void socket_enter_listening(Socket *s) {
1392 r = socket_watch_fds(s);
1394 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1398 socket_set_state(s, SOCKET_LISTENING);
1402 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1405 static void socket_enter_start_post(Socket *s) {
1409 r = socket_open_fds(s);
1411 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1415 socket_unwatch_control_pid(s);
1417 s->control_command_id = SOCKET_EXEC_START_POST;
1419 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1420 r = socket_spawn(s, s->control_command, &s->control_pid);
1422 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1426 socket_set_state(s, SOCKET_START_POST);
1428 socket_enter_listening(s);
1433 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1436 static void socket_enter_start_pre(Socket *s) {
1440 socket_unwatch_control_pid(s);
1442 s->control_command_id = SOCKET_EXEC_START_PRE;
1444 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1445 r = socket_spawn(s, s->control_command, &s->control_pid);
1449 socket_set_state(s, SOCKET_START_PRE);
1451 socket_enter_start_post(s);
1456 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1457 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1460 static void socket_enter_running(Socket *s, int cfd) {
1461 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1466 /* We don't take connections anymore if we are supposed to
1467 * shut down anyway */
1468 if (unit_stop_pending(UNIT(s))) {
1470 log_debug_unit(UNIT(s)->id, "Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1473 close_nointr_nofail(cfd);
1475 /* Flush all sockets by closing and reopening them */
1476 socket_close_fds(s);
1478 r = socket_watch_fds(s);
1480 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1481 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1491 bool pending = false;
1493 /* If there's already a start pending don't bother to
1495 SET_FOREACH(other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1496 if (unit_active_or_pending(other)) {
1502 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1507 socket_set_state(s, SOCKET_RUNNING);
1509 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1512 if (s->n_connections >= s->max_connections) {
1513 log_warning_unit(UNIT(s)->id, "%s: Too many incoming connections (%u)", UNIT(s)->id, s->n_connections);
1514 close_nointr_nofail(cfd);
1518 r = socket_instantiate_service(s);
1522 r = instance_from_socket(cfd, s->n_accepted, &instance);
1527 /* ENOTCONN is legitimate if TCP RST was received.
1528 * This connection is over, but the socket unit lives on. */
1529 close_nointr_nofail(cfd);
1533 prefix = unit_name_to_prefix(UNIT(s)->id);
1539 name = unit_name_build(prefix, instance, ".service");
1545 r = unit_add_name(UNIT_DEREF(s->service), name);
1549 service = SERVICE(UNIT_DEREF(s->service));
1550 unit_ref_unset(&s->service);
1553 UNIT(service)->no_gc = false;
1555 unit_choose_id(UNIT(service), name);
1557 r = service_set_socket_fd(service, cfd, s);
1562 s->n_connections ++;
1564 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1568 /* Notify clients about changed counters */
1569 unit_add_to_dbus_queue(UNIT(s));
1575 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",
1576 UNIT(s)->id, cfd >= 0 ? "template" : "non-template",
1577 bus_error_message(&error, r));
1579 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1582 close_nointr_nofail(cfd);
1585 static void socket_run_next(Socket *s) {
1589 assert(s->control_command);
1590 assert(s->control_command->command_next);
1592 socket_unwatch_control_pid(s);
1594 s->control_command = s->control_command->command_next;
1596 r = socket_spawn(s, s->control_command, &s->control_pid);
1603 log_warning_unit(UNIT(s)->id, "%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1605 if (s->state == SOCKET_START_POST)
1606 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1607 else if (s->state == SOCKET_STOP_POST)
1608 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1610 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1613 static int socket_start(Unit *u) {
1614 Socket *s = SOCKET(u);
1618 /* We cannot fulfill this request right now, try again later
1620 if (s->state == SOCKET_STOP_PRE ||
1621 s->state == SOCKET_STOP_PRE_SIGKILL ||
1622 s->state == SOCKET_STOP_PRE_SIGTERM ||
1623 s->state == SOCKET_STOP_POST ||
1624 s->state == SOCKET_FINAL_SIGTERM ||
1625 s->state == SOCKET_FINAL_SIGKILL)
1628 if (s->state == SOCKET_START_PRE ||
1629 s->state == SOCKET_START_POST)
1632 /* Cannot run this without the service being around */
1633 if (UNIT_ISSET(s->service)) {
1636 service = SERVICE(UNIT_DEREF(s->service));
1638 if (UNIT(service)->load_state != UNIT_LOADED) {
1639 log_error_unit(u->id, "Socket service %s not loaded, refusing.", UNIT(service)->id);
1643 /* If the service is already active we cannot start the
1645 if (service->state != SERVICE_DEAD &&
1646 service->state != SERVICE_FAILED &&
1647 service->state != SERVICE_AUTO_RESTART) {
1648 log_error_unit(u->id, "Socket service %s already active, refusing.", UNIT(service)->id);
1652 #ifdef HAVE_SYSV_COMPAT
1653 if (service->is_sysv) {
1654 log_error_unit(u->id,
1655 "Using SysV services for socket activation is not supported. Refusing.");
1661 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1663 s->result = SOCKET_SUCCESS;
1664 socket_enter_start_pre(s);
1669 static int socket_stop(Unit *u) {
1670 Socket *s = SOCKET(u);
1675 if (s->state == SOCKET_STOP_PRE ||
1676 s->state == SOCKET_STOP_PRE_SIGTERM ||
1677 s->state == SOCKET_STOP_PRE_SIGKILL ||
1678 s->state == SOCKET_STOP_POST ||
1679 s->state == SOCKET_FINAL_SIGTERM ||
1680 s->state == SOCKET_FINAL_SIGKILL)
1683 /* If there's already something running we go directly into
1685 if (s->state == SOCKET_START_PRE ||
1686 s->state == SOCKET_START_POST) {
1687 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1691 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1693 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1697 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1698 Socket *s = SOCKET(u);
1706 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1707 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1708 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1710 if (s->control_pid > 0)
1711 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1713 if (s->control_command_id >= 0)
1714 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1716 LIST_FOREACH(port, p, s->ports) {
1722 copy = fdset_put_dup(fds, p->fd);
1726 if (p->type == SOCKET_SOCKET) {
1727 _cleanup_free_ char *t = NULL;
1729 r = socket_address_print(&p->address, &t);
1733 if (socket_address_family(&p->address) == AF_NETLINK)
1734 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1736 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1738 } else if (p->type == SOCKET_SPECIAL)
1739 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1740 else if (p->type == SOCKET_MQUEUE)
1741 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1743 assert(p->type == SOCKET_FIFO);
1744 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1751 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1752 Socket *s = SOCKET(u);
1758 if (streq(key, "state")) {
1761 state = socket_state_from_string(value);
1763 log_debug_unit(u->id, "Failed to parse state value %s", value);
1765 s->deserialized_state = state;
1766 } else if (streq(key, "result")) {
1769 f = socket_result_from_string(value);
1771 log_debug_unit(u->id, "Failed to parse result value %s", value);
1772 else if (f != SOCKET_SUCCESS)
1775 } else if (streq(key, "n-accepted")) {
1778 if (safe_atou(value, &k) < 0)
1779 log_debug_unit(u->id, "Failed to parse n-accepted value %s", value);
1782 } else if (streq(key, "control-pid")) {
1785 if (parse_pid(value, &pid) < 0)
1786 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1788 s->control_pid = pid;
1789 } else if (streq(key, "control-command")) {
1790 SocketExecCommand id;
1792 id = socket_exec_command_from_string(value);
1794 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1796 s->control_command_id = id;
1797 s->control_command = s->exec_command[id];
1799 } else if (streq(key, "fifo")) {
1803 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1804 log_debug_unit(u->id, "Failed to parse fifo value %s", value);
1807 LIST_FOREACH(port, p, s->ports)
1808 if (p->type == SOCKET_FIFO &&
1809 streq_ptr(p->path, value+skip))
1814 close_nointr_nofail(p->fd);
1815 p->fd = fdset_remove(fds, fd);
1819 } else if (streq(key, "special")) {
1823 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1824 log_debug_unit(u->id, "Failed to parse special value %s", value);
1827 LIST_FOREACH(port, p, s->ports)
1828 if (p->type == SOCKET_SPECIAL &&
1829 streq_ptr(p->path, value+skip))
1834 close_nointr_nofail(p->fd);
1835 p->fd = fdset_remove(fds, fd);
1839 } else if (streq(key, "mqueue")) {
1843 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1844 log_debug_unit(u->id, "Failed to parse mqueue value %s", value);
1847 LIST_FOREACH(port, p, s->ports)
1848 if (p->type == SOCKET_MQUEUE &&
1849 streq_ptr(p->path, value+skip))
1854 close_nointr_nofail(p->fd);
1855 p->fd = fdset_remove(fds, fd);
1859 } else if (streq(key, "socket")) {
1860 int fd, type, skip = 0;
1863 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1864 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1867 LIST_FOREACH(port, p, s->ports)
1868 if (socket_address_is(&p->address, value+skip, type))
1873 close_nointr_nofail(p->fd);
1874 p->fd = fdset_remove(fds, fd);
1878 } else if (streq(key, "netlink")) {
1882 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1883 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1886 LIST_FOREACH(port, p, s->ports)
1887 if (socket_address_is_netlink(&p->address, value+skip))
1892 close_nointr_nofail(p->fd);
1893 p->fd = fdset_remove(fds, fd);
1897 log_debug_unit(UNIT(s)->id, "Unknown serialization key '%s'", key);
1902 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1903 Socket *s = SOCKET(u);
1908 LIST_FOREACH(port, p, s->ports) {
1912 if (p->type != SOCKET_SOCKET)
1918 FDSET_FOREACH(fd, fds, i) {
1919 if (socket_address_matches_fd(&p->address, fd)) {
1920 p->fd = fdset_remove(fds, fd);
1921 s->deserialized_state = SOCKET_LISTENING;
1930 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1933 return state_translation_table[SOCKET(u)->state];
1936 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1939 return socket_state_to_string(SOCKET(u)->state);
1942 const char* socket_port_type_to_string(SocketPort *p) {
1950 switch (p->address.type) {
1958 case SOCK_SEQPACKET:
1959 return "SequentialPacket";
1962 if (socket_address_family(&p->address) == AF_NETLINK)
1969 case SOCKET_SPECIAL:
1973 return "MessageQueue";
1983 _pure_ static bool socket_check_gc(Unit *u) {
1984 Socket *s = SOCKET(u);
1988 return s->n_connections > 0;
1991 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1992 SocketPort *p = userdata;
1998 if (p->socket->state != SOCKET_LISTENING)
2001 log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
2003 if (revents != EPOLLIN) {
2005 if (revents & EPOLLHUP)
2006 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.",
2007 UNIT(p->socket)->id);
2009 log_error_unit(UNIT(p->socket)->id, "%s: Got unexpected poll event (0x%x) on socket.",
2010 UNIT(p->socket)->id, revents);
2015 if (p->socket->accept &&
2016 p->type == SOCKET_SOCKET &&
2017 socket_address_can_accept(&p->address)) {
2021 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2027 log_error_unit(UNIT(p->socket)->id,
2028 "Failed to accept socket: %m");
2035 socket_apply_socket_options(p->socket, cfd);
2038 socket_enter_running(p->socket, cfd);
2042 socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2046 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2047 Socket *s = SOCKET(u);
2053 if (pid != s->control_pid)
2058 if (is_clean_exit(code, status, NULL))
2060 else if (code == CLD_EXITED)
2061 f = SOCKET_FAILURE_EXIT_CODE;
2062 else if (code == CLD_KILLED)
2063 f = SOCKET_FAILURE_SIGNAL;
2064 else if (code == CLD_DUMPED)
2065 f = SOCKET_FAILURE_CORE_DUMP;
2067 assert_not_reached("Unknown code");
2069 if (s->control_command) {
2070 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2072 if (s->control_command->ignore)
2076 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2078 "%s control process exited, code=%s status=%i",
2079 u->id, sigchld_code_to_string(code), status);
2081 if (f != SOCKET_SUCCESS)
2084 if (s->control_command &&
2085 s->control_command->command_next &&
2086 f == SOCKET_SUCCESS) {
2088 log_debug_unit(u->id,
2089 "%s running next command for state %s",
2090 u->id, socket_state_to_string(s->state));
2093 s->control_command = NULL;
2094 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2096 /* No further commands for this step, so let's figure
2097 * out what to do next */
2099 log_debug_unit(u->id,
2100 "%s got final SIGCHLD for state %s",
2101 u->id, socket_state_to_string(s->state));
2105 case SOCKET_START_PRE:
2106 if (f == SOCKET_SUCCESS)
2107 socket_enter_start_post(s);
2109 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2112 case SOCKET_START_POST:
2113 if (f == SOCKET_SUCCESS)
2114 socket_enter_listening(s);
2116 socket_enter_stop_pre(s, f);
2119 case SOCKET_STOP_PRE:
2120 case SOCKET_STOP_PRE_SIGTERM:
2121 case SOCKET_STOP_PRE_SIGKILL:
2122 socket_enter_stop_post(s, f);
2125 case SOCKET_STOP_POST:
2126 case SOCKET_FINAL_SIGTERM:
2127 case SOCKET_FINAL_SIGKILL:
2128 socket_enter_dead(s, f);
2132 assert_not_reached("Uh, control process died at wrong time.");
2136 /* Notify clients about changed exit status */
2137 unit_add_to_dbus_queue(u);
2140 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2141 Socket *s = SOCKET(userdata);
2144 assert(s->timer_event_source == source);
2148 case SOCKET_START_PRE:
2149 log_warning_unit(UNIT(s)->id,
2150 "%s starting timed out. Terminating.", UNIT(s)->id);
2151 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2154 case SOCKET_START_POST:
2155 log_warning_unit(UNIT(s)->id,
2156 "%s starting timed out. Stopping.", UNIT(s)->id);
2157 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2160 case SOCKET_STOP_PRE:
2161 log_warning_unit(UNIT(s)->id,
2162 "%s stopping timed out. Terminating.", UNIT(s)->id);
2163 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2166 case SOCKET_STOP_PRE_SIGTERM:
2167 if (s->kill_context.send_sigkill) {
2168 log_warning_unit(UNIT(s)->id,
2169 "%s stopping timed out. Killing.", UNIT(s)->id);
2170 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2172 log_warning_unit(UNIT(s)->id,
2173 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2175 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2179 case SOCKET_STOP_PRE_SIGKILL:
2180 log_warning_unit(UNIT(s)->id,
2181 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2182 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2185 case SOCKET_STOP_POST:
2186 log_warning_unit(UNIT(s)->id,
2187 "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2188 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2191 case SOCKET_FINAL_SIGTERM:
2192 if (s->kill_context.send_sigkill) {
2193 log_warning_unit(UNIT(s)->id,
2194 "%s stopping timed out (2). Killing.", UNIT(s)->id);
2195 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2197 log_warning_unit(UNIT(s)->id,
2198 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2200 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2204 case SOCKET_FINAL_SIGKILL:
2205 log_warning_unit(UNIT(s)->id,
2206 "%s still around after SIGKILL (2). Entering failed mode.",
2208 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2212 assert_not_reached("Timeout at wrong time.");
2218 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2227 /* Called from the service code for requesting our fds */
2230 LIST_FOREACH(port, p, s->ports)
2240 if (!(rfds = new(int, rn_fds)))
2244 LIST_FOREACH(port, p, s->ports)
2248 assert(k == rn_fds);
2256 static void socket_reset_failed(Unit *u) {
2257 Socket *s = SOCKET(u);
2261 if (s->state == SOCKET_FAILED)
2262 socket_set_state(s, SOCKET_DEAD);
2264 s->result = SOCKET_SUCCESS;
2267 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2270 /* The service is dead. Dang!
2272 * This is strictly for one-instance-for-all-connections
2275 if (s->state == SOCKET_RUNNING) {
2276 log_debug_unit(UNIT(s)->id, "%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2277 if (failed_permanent)
2278 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2280 socket_enter_listening(s);
2284 void socket_connection_unref(Socket *s) {
2287 /* The service is dead. Yay!
2289 * This is strictly for one-instance-per-connection
2292 assert(s->n_connections > 0);
2295 log_debug_unit(UNIT(s)->id, "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2298 static void socket_trigger_notify(Unit *u, Unit *other) {
2299 Socket *s = SOCKET(u);
2305 /* Don't propagate state changes from the service if we are
2306 already down or accepting connections */
2307 if ((s->state != SOCKET_RUNNING &&
2308 s->state != SOCKET_LISTENING) ||
2312 if (other->load_state != UNIT_LOADED ||
2313 other->type != UNIT_SERVICE)
2316 se = SERVICE(other);
2318 if (se->state == SERVICE_FAILED)
2319 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2321 if (se->state == SERVICE_DEAD ||
2322 se->state == SERVICE_STOP ||
2323 se->state == SERVICE_STOP_SIGTERM ||
2324 se->state == SERVICE_STOP_SIGKILL ||
2325 se->state == SERVICE_STOP_POST ||
2326 se->state == SERVICE_FINAL_SIGTERM ||
2327 se->state == SERVICE_FINAL_SIGKILL ||
2328 se->state == SERVICE_AUTO_RESTART)
2329 socket_notify_service_dead(s, false);
2331 if (se->state == SERVICE_RUNNING)
2332 socket_set_state(s, SOCKET_RUNNING);
2335 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2336 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2339 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2340 [SOCKET_DEAD] = "dead",
2341 [SOCKET_START_PRE] = "start-pre",
2342 [SOCKET_START_POST] = "start-post",
2343 [SOCKET_LISTENING] = "listening",
2344 [SOCKET_RUNNING] = "running",
2345 [SOCKET_STOP_PRE] = "stop-pre",
2346 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2347 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2348 [SOCKET_STOP_POST] = "stop-post",
2349 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2350 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2351 [SOCKET_FAILED] = "failed"
2354 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2356 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2357 [SOCKET_EXEC_START_PRE] = "StartPre",
2358 [SOCKET_EXEC_START_POST] = "StartPost",
2359 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2360 [SOCKET_EXEC_STOP_POST] = "StopPost"
2363 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2365 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2366 [SOCKET_SUCCESS] = "success",
2367 [SOCKET_FAILURE_RESOURCES] = "resources",
2368 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2369 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2370 [SOCKET_FAILURE_SIGNAL] = "signal",
2371 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2372 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2375 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2377 const UnitVTable socket_vtable = {
2378 .object_size = sizeof(Socket),
2379 .exec_context_offset = offsetof(Socket, exec_context),
2380 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2381 .kill_context_offset = offsetof(Socket, kill_context),
2382 .exec_runtime_offset = offsetof(Socket, exec_runtime),
2388 .private_section = "Socket",
2390 .init = socket_init,
2391 .done = socket_done,
2392 .load = socket_load,
2394 .coldplug = socket_coldplug,
2396 .dump = socket_dump,
2398 .start = socket_start,
2399 .stop = socket_stop,
2401 .kill = socket_kill,
2403 .serialize = socket_serialize,
2404 .deserialize_item = socket_deserialize_item,
2405 .distribute_fds = socket_distribute_fds,
2407 .active_state = socket_active_state,
2408 .sub_state_to_string = socket_sub_state_to_string,
2410 .check_gc = socket_check_gc,
2412 .sigchld_event = socket_sigchld_event,
2414 .trigger_notify = socket_trigger_notify,
2416 .reset_failed = socket_reset_failed,
2418 .bus_interface = "org.freedesktop.systemd1.Socket",
2419 .bus_vtable = bus_socket_vtable,
2420 .bus_changing_properties = bus_socket_changing_properties,
2421 .bus_set_property = bus_socket_set_property,
2422 .bus_commit_properties = bus_socket_commit_properties,
2424 .status_message_formats = {
2425 /*.starting_stopping = {
2426 [0] = "Starting socket %s...",
2427 [1] = "Stopping socket %s...",
2429 .finished_start_job = {
2430 [JOB_DONE] = "Listening on %s.",
2431 [JOB_FAILED] = "Failed to listen on %s.",
2432 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2433 [JOB_TIMEOUT] = "Timed out starting %s.",
2435 .finished_stop_job = {
2436 [JOB_DONE] = "Closed %s.",
2437 [JOB_FAILED] = "Failed stopping %s.",
2438 [JOB_TIMEOUT] = "Timed out stopping %s.",