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 s->exec_context.std_output = u->manager->default_std_output;
94 s->exec_context.std_error = u->manager->default_std_error;
96 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
99 static void socket_unwatch_control_pid(Socket *s) {
102 if (s->control_pid <= 0)
105 unit_unwatch_pid(UNIT(s), s->control_pid);
109 void socket_free_ports(Socket *s) {
114 while ((p = s->ports)) {
115 LIST_REMOVE(port, s->ports, p);
117 sd_event_source_unref(p->event_source);
125 static void socket_done(Unit *u) {
126 Socket *s = SOCKET(u);
130 socket_free_ports(s);
132 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
133 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
134 s->control_command = NULL;
136 socket_unwatch_control_pid(s);
138 unit_ref_unset(&s->service);
140 free(s->tcp_congestion);
141 s->tcp_congestion = NULL;
143 free(s->bind_to_device);
144 s->bind_to_device = NULL;
147 free(s->smack_ip_in);
148 free(s->smack_ip_out);
150 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
153 static int socket_arm_timer(Socket *s) {
158 if (s->timeout_usec <= 0) {
159 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
163 if (s->timer_event_source) {
164 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec);
168 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
171 return sd_event_add_time(
172 UNIT(s)->manager->event,
173 &s->timer_event_source,
175 now(CLOCK_MONOTONIC) + s->timeout_usec, 0,
176 socket_dispatch_timer, s);
179 static int socket_instantiate_service(Socket *s) {
180 _cleanup_free_ char *prefix = NULL;
181 _cleanup_free_ char *name = NULL;
187 /* This fills in s->service if it isn't filled in yet. For
188 * Accept=yes sockets we create the next connection service
189 * here. For Accept=no this is mostly a NOP since the service
190 * is figured out at load time anyway. */
192 if (UNIT_DEREF(s->service))
197 prefix = unit_name_to_prefix(UNIT(s)->id);
201 if (asprintf(&name, "%s@%u.service", prefix, s->n_accepted) < 0)
204 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
208 #ifdef HAVE_SYSV_COMPAT
209 if (SERVICE(u)->is_sysv) {
210 log_error("Using SysV services for socket activation is not supported. Refusing.");
216 unit_ref_set(&s->service, u);
218 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
221 static bool have_non_accept_socket(Socket *s) {
229 LIST_FOREACH(port, p, s->ports) {
231 if (p->type != SOCKET_SOCKET)
234 if (!socket_address_can_accept(&p->address))
241 static int socket_add_mount_links(Socket *s) {
247 LIST_FOREACH(port, p, s->ports) {
248 const char *path = NULL;
250 if (p->type == SOCKET_SOCKET)
251 path = socket_address_get_path(&p->address);
252 else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL)
258 r = unit_require_mounts_for(UNIT(s), path);
266 static int socket_add_device_link(Socket *s) {
271 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
274 t = strappenda("/sys/subsystem/net/devices/", s->bind_to_device);
275 return unit_add_node_link(UNIT(s), t, false);
278 static int socket_add_default_dependencies(Socket *s) {
282 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
286 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
287 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
292 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
295 _pure_ static bool socket_has_exec(Socket *s) {
299 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
300 if (s->exec_command[i])
306 static int socket_add_extras(Socket *s) {
312 if (have_non_accept_socket(s)) {
314 if (!UNIT_DEREF(s->service)) {
317 r = unit_load_related_unit(u, ".service", &x);
321 unit_ref_set(&s->service, x);
324 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
329 r = socket_add_mount_links(s);
333 r = socket_add_device_link(s);
337 r = unit_patch_contexts(u);
341 if (socket_has_exec(s)) {
342 r = unit_add_exec_dependencies(u, &s->exec_context);
346 r = unit_add_default_slice(u, &s->cgroup_context);
351 if (u->default_dependencies) {
352 r = socket_add_default_dependencies(s);
360 static int socket_verify(Socket *s) {
363 if (UNIT(s)->load_state != UNIT_LOADED)
367 log_error_unit(UNIT(s)->id, "%s lacks Listen setting. Refusing.", UNIT(s)->id);
371 if (s->accept && have_non_accept_socket(s)) {
372 log_error_unit(UNIT(s)->id, "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
377 if (s->accept && s->max_connections <= 0) {
378 log_error_unit(UNIT(s)->id, "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
382 if (s->accept && UNIT_DEREF(s->service)) {
383 log_error_unit(UNIT(s)->id, "Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
387 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
388 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
395 static int socket_load(Unit *u) {
396 Socket *s = SOCKET(u);
400 assert(u->load_state == UNIT_STUB);
402 r = unit_load_fragment_and_dropin(u);
406 if (u->load_state == UNIT_LOADED) {
407 /* This is a new unit? Then let's add in some extras */
408 r = socket_add_extras(s);
413 return socket_verify(s);
416 _const_ static const char* listen_lookup(int family, int type) {
418 if (family == AF_NETLINK)
419 return "ListenNetlink";
421 if (type == SOCK_STREAM)
422 return "ListenStream";
423 else if (type == SOCK_DGRAM)
424 return "ListenDatagram";
425 else if (type == SOCK_SEQPACKET)
426 return "ListenSequentialPacket";
428 assert_not_reached("Unknown socket type");
432 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
434 Socket *s = SOCKET(u);
441 prefix2 = strappenda(prefix, "\t");
444 "%sSocket State: %s\n"
446 "%sBindIPv6Only: %s\n"
448 "%sSocketMode: %04o\n"
449 "%sDirectoryMode: %04o\n"
452 "%sTransparent: %s\n"
454 "%sPassCredentials: %s\n"
455 "%sPassSecurity: %s\n"
456 "%sTCPCongestion: %s\n",
457 prefix, socket_state_to_string(s->state),
458 prefix, socket_result_to_string(s->result),
459 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
461 prefix, s->socket_mode,
462 prefix, s->directory_mode,
463 prefix, yes_no(s->keep_alive),
464 prefix, yes_no(s->free_bind),
465 prefix, yes_no(s->transparent),
466 prefix, yes_no(s->broadcast),
467 prefix, yes_no(s->pass_cred),
468 prefix, yes_no(s->pass_sec),
469 prefix, strna(s->tcp_congestion));
471 if (s->control_pid > 0)
473 "%sControl PID: %lu\n",
474 prefix, (unsigned long) s->control_pid);
476 if (s->bind_to_device)
478 "%sBindToDevice: %s\n",
479 prefix, s->bind_to_device);
484 "%sNConnections: %u\n"
485 "%sMaxConnections: %u\n",
486 prefix, s->n_accepted,
487 prefix, s->n_connections,
488 prefix, s->max_connections);
490 if (s->priority >= 0)
493 prefix, s->priority);
495 if (s->receive_buffer > 0)
497 "%sReceiveBuffer: %zu\n",
498 prefix, s->receive_buffer);
500 if (s->send_buffer > 0)
502 "%sSendBuffer: %zu\n",
503 prefix, s->send_buffer);
515 if (s->pipe_size > 0)
518 prefix, s->pipe_size);
525 if (s->mq_maxmsg > 0)
527 "%sMessageQueueMaxMessages: %li\n",
528 prefix, s->mq_maxmsg);
530 if (s->mq_msgsize > 0)
532 "%sMessageQueueMessageSize: %li\n",
533 prefix, s->mq_msgsize);
538 prefix, yes_no(s->reuse_port));
542 "%sSmackLabel: %s\n",
547 "%sSmackLabelIPIn: %s\n",
548 prefix, s->smack_ip_in);
552 "%sSmackLabelIPOut: %s\n",
553 prefix, s->smack_ip_out);
555 LIST_FOREACH(port, p, s->ports) {
557 if (p->type == SOCKET_SOCKET) {
562 if ((r = socket_address_print(&p->address, &k)) < 0)
567 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
569 } else if (p->type == SOCKET_SPECIAL)
570 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
571 else if (p->type == SOCKET_MQUEUE)
572 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
574 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
577 exec_context_dump(&s->exec_context, f, prefix);
578 kill_context_dump(&s->kill_context, f, prefix);
580 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
581 if (!s->exec_command[c])
584 fprintf(f, "%s-> %s:\n",
585 prefix, socket_exec_command_to_string(c));
587 exec_command_dump_list(s->exec_command[c], f, prefix2);
591 static int instance_from_socket(int fd, unsigned nr, char **instance) {
594 union sockaddr_union local, remote;
600 if (getsockname(fd, &local.sa, &l) < 0)
604 if (getpeername(fd, &remote.sa, &l) < 0)
607 switch (local.sa.sa_family) {
611 a = ntohl(local.in.sin_addr.s_addr),
612 b = ntohl(remote.in.sin_addr.s_addr);
615 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
617 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
618 ntohs(local.in.sin_port),
619 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
620 ntohs(remote.in.sin_port)) < 0)
627 static const unsigned char ipv4_prefix[] = {
628 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
631 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
632 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
634 *a = local.in6.sin6_addr.s6_addr+12,
635 *b = remote.in6.sin6_addr.s6_addr+12;
638 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
640 a[0], a[1], a[2], a[3],
641 ntohs(local.in6.sin6_port),
642 b[0], b[1], b[2], b[3],
643 ntohs(remote.in6.sin6_port)) < 0)
646 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
651 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
652 ntohs(local.in6.sin6_port),
653 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
654 ntohs(remote.in6.sin6_port)) < 0)
665 k = getpeercred(fd, &ucred);
672 (unsigned long) ucred.pid,
673 (unsigned long) ucred.uid) < 0)
680 assert_not_reached("Unhandled socket type.");
687 static void socket_close_fds(Socket *s) {
692 LIST_FOREACH(port, p, s->ports) {
694 p->event_source = sd_event_source_unref(p->event_source);
699 p->fd = safe_close(p->fd);
701 /* One little note: we should never delete any sockets
702 * in the file system here! After all some other
703 * process we spawned might still have a reference of
704 * this fd and wants to continue to use it. Therefore
705 * we delete sockets in the file system before we
706 * create a new one, not after we stopped using
711 static void socket_apply_socket_options(Socket *s, int fd) {
716 int b = s->keep_alive;
717 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
718 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
723 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
724 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
729 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
730 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
735 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
736 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
739 if (s->priority >= 0)
740 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
741 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
743 if (s->receive_buffer > 0) {
744 int value = (int) s->receive_buffer;
746 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
748 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
749 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
750 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
753 if (s->send_buffer > 0) {
754 int value = (int) s->send_buffer;
755 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
756 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
757 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
761 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
762 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
765 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
766 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
768 if (s->ip_ttl >= 0) {
771 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
773 if (socket_ipv6_is_supported())
774 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
777 errno = EAFNOSUPPORT;
781 log_warning_unit(UNIT(s)->id,
782 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
785 if (s->tcp_congestion)
786 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
787 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
790 int b = s->reuse_port;
791 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)) < 0)
792 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
796 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
797 log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
800 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
801 log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
804 static void socket_apply_fifo_options(Socket *s, int fd) {
808 if (s->pipe_size > 0)
809 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
810 log_warning_unit(UNIT(s)->id,
814 if (smack_label_fd(fd, s->smack) < 0)
815 log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
818 static int fifo_address_create(
820 mode_t directory_mode,
831 mkdir_parents_label(path, directory_mode);
833 r = label_context_set(path, S_IFIFO);
837 /* Enforce the right access mode for the fifo */
838 old_mask = umask(~ socket_mode);
840 /* Include the original umask in our mask */
841 umask(~socket_mode | old_mask);
843 r = mkfifo(path, socket_mode);
846 if (r < 0 && errno != EEXIST) {
851 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
856 label_context_clear();
858 if (fstat(fd, &st) < 0) {
863 if (!S_ISFIFO(st.st_mode) ||
864 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
865 st.st_uid != getuid() ||
866 st.st_gid != getgid()) {
876 label_context_clear();
882 static int special_address_create(
892 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
897 if (fstat(fd, &st) < 0) {
902 /* Check whether this is a /proc, /sys or /dev file or char device */
903 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
917 static int mq_address_create(
927 struct mq_attr _attr, *attr = NULL;
932 if (maxmsg > 0 && msgsize > 0) {
934 _attr.mq_flags = O_NONBLOCK;
935 _attr.mq_maxmsg = maxmsg;
936 _attr.mq_msgsize = msgsize;
940 /* Enforce the right access mode for the mq */
941 old_mask = umask(~ mq_mode);
943 /* Include the original umask in our mask */
944 umask(~mq_mode | old_mask);
946 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
954 if (fstat(fd, &st) < 0) {
959 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
960 st.st_uid != getuid() ||
961 st.st_gid != getgid()) {
975 static int socket_open_fds(Socket *s) {
979 bool know_label = false;
983 LIST_FOREACH(port, p, s->ports) {
988 if (p->type == SOCKET_SOCKET) {
992 if ((r = socket_instantiate_service(s)) < 0)
995 if (UNIT_ISSET(s->service) &&
996 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
997 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1008 r = socket_address_listen(
1010 SOCK_CLOEXEC|SOCK_NONBLOCK,
1023 socket_apply_socket_options(s, p->fd);
1025 } else if (p->type == SOCKET_SPECIAL) {
1027 r = special_address_create(
1033 } else if (p->type == SOCKET_FIFO) {
1035 r = fifo_address_create(
1043 socket_apply_fifo_options(s, p->fd);
1044 } else if (p->type == SOCKET_MQUEUE) {
1046 r = mq_address_create(
1055 assert_not_reached("Unknown port type");
1062 socket_close_fds(s);
1067 static void socket_unwatch_fds(Socket *s) {
1073 LIST_FOREACH(port, p, s->ports) {
1077 if (p->event_source) {
1078 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_OFF);
1080 log_debug_unit(UNIT(s)->id, "Failed to disable event source.");
1085 static int socket_watch_fds(Socket *s) {
1091 LIST_FOREACH(port, p, s->ports) {
1095 if (p->event_source)
1096 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1098 r = sd_event_add_io(UNIT(s)->manager->event, &p->event_source, p->fd, EPOLLIN, socket_dispatch_io, p);
1101 log_warning_unit(UNIT(s)->id, "Failed to watch listening fds: %s", strerror(-r));
1109 socket_unwatch_fds(s);
1113 static void socket_set_state(Socket *s, SocketState state) {
1114 SocketState old_state;
1117 old_state = s->state;
1120 if (state != SOCKET_START_PRE &&
1121 state != SOCKET_START_POST &&
1122 state != SOCKET_STOP_PRE &&
1123 state != SOCKET_STOP_PRE_SIGTERM &&
1124 state != SOCKET_STOP_PRE_SIGKILL &&
1125 state != SOCKET_STOP_POST &&
1126 state != SOCKET_FINAL_SIGTERM &&
1127 state != SOCKET_FINAL_SIGKILL) {
1129 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1130 socket_unwatch_control_pid(s);
1131 s->control_command = NULL;
1132 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1135 if (state != SOCKET_LISTENING)
1136 socket_unwatch_fds(s);
1138 if (state != SOCKET_START_POST &&
1139 state != SOCKET_LISTENING &&
1140 state != SOCKET_RUNNING &&
1141 state != SOCKET_STOP_PRE &&
1142 state != SOCKET_STOP_PRE_SIGTERM &&
1143 state != SOCKET_STOP_PRE_SIGKILL)
1144 socket_close_fds(s);
1146 if (state != old_state)
1147 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s",
1148 UNIT(s)->id, socket_state_to_string(old_state), socket_state_to_string(state));
1150 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1153 static int socket_coldplug(Unit *u) {
1154 Socket *s = SOCKET(u);
1158 assert(s->state == SOCKET_DEAD);
1160 if (s->deserialized_state == s->state)
1163 if (s->deserialized_state == SOCKET_START_PRE ||
1164 s->deserialized_state == SOCKET_START_POST ||
1165 s->deserialized_state == SOCKET_STOP_PRE ||
1166 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1167 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1168 s->deserialized_state == SOCKET_STOP_POST ||
1169 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1170 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1172 if (s->control_pid <= 0)
1175 r = unit_watch_pid(UNIT(s), s->control_pid);
1179 r = socket_arm_timer(s);
1184 if (s->deserialized_state == SOCKET_START_POST ||
1185 s->deserialized_state == SOCKET_LISTENING ||
1186 s->deserialized_state == SOCKET_RUNNING ||
1187 s->deserialized_state == SOCKET_STOP_PRE ||
1188 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1189 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL) {
1190 r = socket_open_fds(s);
1195 if (s->deserialized_state == SOCKET_LISTENING) {
1196 r = socket_watch_fds(s);
1201 socket_set_state(s, s->deserialized_state);
1205 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1214 unit_realize_cgroup(UNIT(s));
1216 r = unit_setup_exec_runtime(UNIT(s));
1220 r = socket_arm_timer(s);
1224 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1232 UNIT(s)->manager->environment,
1236 UNIT(s)->manager->confirm_spawn,
1237 UNIT(s)->manager->cgroup_supported,
1238 UNIT(s)->cgroup_path,
1239 manager_get_runtime_prefix(UNIT(s)->manager),
1250 r = unit_watch_pid(UNIT(s), pid);
1252 /* FIXME: we need to do something here */
1260 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1265 static void socket_enter_dead(Socket *s, SocketResult f) {
1268 if (f != SOCKET_SUCCESS)
1271 exec_runtime_destroy(s->exec_runtime);
1272 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1274 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1276 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1279 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1281 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1285 if (f != SOCKET_SUCCESS)
1288 socket_unwatch_control_pid(s);
1290 s->control_command_id = SOCKET_EXEC_STOP_POST;
1292 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1293 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1296 socket_set_state(s, SOCKET_STOP_POST);
1298 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1303 log_warning_unit(UNIT(s)->id,
1304 "%s failed to run 'stop-post' task: %s",
1305 UNIT(s)->id, strerror(-r));
1306 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1309 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1314 if (f != SOCKET_SUCCESS)
1317 r = unit_kill_context(
1320 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1328 r = socket_arm_timer(s);
1332 socket_set_state(s, state);
1333 } else if (state == SOCKET_STOP_PRE_SIGTERM)
1334 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_SUCCESS);
1335 else if (state == SOCKET_STOP_PRE_SIGKILL)
1336 socket_enter_stop_post(s, SOCKET_SUCCESS);
1337 else if (state == SOCKET_FINAL_SIGTERM)
1338 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
1340 socket_enter_dead(s, SOCKET_SUCCESS);
1345 log_warning_unit(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1347 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1348 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1350 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1353 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1357 if (f != SOCKET_SUCCESS)
1360 socket_unwatch_control_pid(s);
1362 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1364 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1365 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1368 socket_set_state(s, SOCKET_STOP_PRE);
1370 socket_enter_stop_post(s, SOCKET_SUCCESS);
1375 log_warning_unit(UNIT(s)->id, "%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1376 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1379 static void socket_enter_listening(Socket *s) {
1383 r = socket_watch_fds(s);
1385 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1389 socket_set_state(s, SOCKET_LISTENING);
1393 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1396 static void socket_enter_start_post(Socket *s) {
1400 r = socket_open_fds(s);
1402 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1406 socket_unwatch_control_pid(s);
1408 s->control_command_id = SOCKET_EXEC_START_POST;
1410 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1411 r = socket_spawn(s, s->control_command, &s->control_pid);
1413 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1417 socket_set_state(s, SOCKET_START_POST);
1419 socket_enter_listening(s);
1424 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1427 static void socket_enter_start_pre(Socket *s) {
1431 socket_unwatch_control_pid(s);
1433 s->control_command_id = SOCKET_EXEC_START_PRE;
1435 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1436 r = socket_spawn(s, s->control_command, &s->control_pid);
1440 socket_set_state(s, SOCKET_START_PRE);
1442 socket_enter_start_post(s);
1447 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1448 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1451 static void socket_enter_running(Socket *s, int cfd) {
1452 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1457 /* We don't take connections anymore if we are supposed to
1458 * shut down anyway */
1459 if (unit_stop_pending(UNIT(s))) {
1461 log_debug_unit(UNIT(s)->id, "Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1466 /* Flush all sockets by closing and reopening them */
1467 socket_close_fds(s);
1469 r = socket_open_fds(s);
1471 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1472 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1476 r = socket_watch_fds(s);
1478 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1479 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1489 bool pending = false;
1491 /* If there's already a start pending don't bother to
1493 SET_FOREACH(other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1494 if (unit_active_or_pending(other)) {
1500 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1505 socket_set_state(s, SOCKET_RUNNING);
1507 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1510 if (s->n_connections >= s->max_connections) {
1511 log_warning_unit(UNIT(s)->id, "%s: Too many incoming connections (%u)", UNIT(s)->id, s->n_connections);
1516 r = socket_instantiate_service(s);
1520 r = instance_from_socket(cfd, s->n_accepted, &instance);
1525 /* ENOTCONN is legitimate if TCP RST was received.
1526 * This connection is over, but the socket unit lives on. */
1531 prefix = unit_name_to_prefix(UNIT(s)->id);
1537 name = unit_name_build(prefix, instance, ".service");
1543 r = unit_add_name(UNIT_DEREF(s->service), name);
1547 service = SERVICE(UNIT_DEREF(s->service));
1548 unit_ref_unset(&s->service);
1551 UNIT(service)->no_gc = false;
1553 unit_choose_id(UNIT(service), name);
1555 r = service_set_socket_fd(service, cfd, s);
1560 s->n_connections ++;
1562 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1566 /* Notify clients about changed counters */
1567 unit_add_to_dbus_queue(UNIT(s));
1573 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",
1574 UNIT(s)->id, cfd >= 0 ? "template" : "non-template",
1575 bus_error_message(&error, r));
1577 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1581 static void socket_run_next(Socket *s) {
1585 assert(s->control_command);
1586 assert(s->control_command->command_next);
1588 socket_unwatch_control_pid(s);
1590 s->control_command = s->control_command->command_next;
1592 r = socket_spawn(s, s->control_command, &s->control_pid);
1599 log_warning_unit(UNIT(s)->id, "%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1601 if (s->state == SOCKET_START_POST)
1602 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1603 else if (s->state == SOCKET_STOP_POST)
1604 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1606 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1609 static int socket_start(Unit *u) {
1610 Socket *s = SOCKET(u);
1614 /* We cannot fulfill this request right now, try again later
1616 if (s->state == SOCKET_STOP_PRE ||
1617 s->state == SOCKET_STOP_PRE_SIGKILL ||
1618 s->state == SOCKET_STOP_PRE_SIGTERM ||
1619 s->state == SOCKET_STOP_POST ||
1620 s->state == SOCKET_FINAL_SIGTERM ||
1621 s->state == SOCKET_FINAL_SIGKILL)
1624 if (s->state == SOCKET_START_PRE ||
1625 s->state == SOCKET_START_POST)
1628 /* Cannot run this without the service being around */
1629 if (UNIT_ISSET(s->service)) {
1632 service = SERVICE(UNIT_DEREF(s->service));
1634 if (UNIT(service)->load_state != UNIT_LOADED) {
1635 log_error_unit(u->id, "Socket service %s not loaded, refusing.", UNIT(service)->id);
1639 /* If the service is already active we cannot start the
1641 if (service->state != SERVICE_DEAD &&
1642 service->state != SERVICE_FAILED &&
1643 service->state != SERVICE_AUTO_RESTART) {
1644 log_error_unit(u->id, "Socket service %s already active, refusing.", UNIT(service)->id);
1648 #ifdef HAVE_SYSV_COMPAT
1649 if (service->is_sysv) {
1650 log_error_unit(u->id,
1651 "Using SysV services for socket activation is not supported. Refusing.");
1657 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1659 s->result = SOCKET_SUCCESS;
1660 socket_enter_start_pre(s);
1665 static int socket_stop(Unit *u) {
1666 Socket *s = SOCKET(u);
1671 if (s->state == SOCKET_STOP_PRE ||
1672 s->state == SOCKET_STOP_PRE_SIGTERM ||
1673 s->state == SOCKET_STOP_PRE_SIGKILL ||
1674 s->state == SOCKET_STOP_POST ||
1675 s->state == SOCKET_FINAL_SIGTERM ||
1676 s->state == SOCKET_FINAL_SIGKILL)
1679 /* If there's already something running we go directly into
1681 if (s->state == SOCKET_START_PRE ||
1682 s->state == SOCKET_START_POST) {
1683 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1687 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1689 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1693 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1694 Socket *s = SOCKET(u);
1702 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1703 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1704 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1706 if (s->control_pid > 0)
1707 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1709 if (s->control_command_id >= 0)
1710 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1712 LIST_FOREACH(port, p, s->ports) {
1718 copy = fdset_put_dup(fds, p->fd);
1722 if (p->type == SOCKET_SOCKET) {
1723 _cleanup_free_ char *t = NULL;
1725 r = socket_address_print(&p->address, &t);
1729 if (socket_address_family(&p->address) == AF_NETLINK)
1730 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1732 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1734 } else if (p->type == SOCKET_SPECIAL)
1735 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1736 else if (p->type == SOCKET_MQUEUE)
1737 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1739 assert(p->type == SOCKET_FIFO);
1740 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1747 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1748 Socket *s = SOCKET(u);
1754 if (streq(key, "state")) {
1757 state = socket_state_from_string(value);
1759 log_debug_unit(u->id, "Failed to parse state value %s", value);
1761 s->deserialized_state = state;
1762 } else if (streq(key, "result")) {
1765 f = socket_result_from_string(value);
1767 log_debug_unit(u->id, "Failed to parse result value %s", value);
1768 else if (f != SOCKET_SUCCESS)
1771 } else if (streq(key, "n-accepted")) {
1774 if (safe_atou(value, &k) < 0)
1775 log_debug_unit(u->id, "Failed to parse n-accepted value %s", value);
1778 } else if (streq(key, "control-pid")) {
1781 if (parse_pid(value, &pid) < 0)
1782 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1784 s->control_pid = pid;
1785 } else if (streq(key, "control-command")) {
1786 SocketExecCommand id;
1788 id = socket_exec_command_from_string(value);
1790 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1792 s->control_command_id = id;
1793 s->control_command = s->exec_command[id];
1795 } else if (streq(key, "fifo")) {
1799 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1800 log_debug_unit(u->id, "Failed to parse fifo value %s", value);
1803 LIST_FOREACH(port, p, s->ports)
1804 if (p->type == SOCKET_FIFO &&
1805 streq_ptr(p->path, value+skip))
1810 p->fd = fdset_remove(fds, fd);
1814 } else if (streq(key, "special")) {
1818 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1819 log_debug_unit(u->id, "Failed to parse special value %s", value);
1822 LIST_FOREACH(port, p, s->ports)
1823 if (p->type == SOCKET_SPECIAL &&
1824 streq_ptr(p->path, value+skip))
1829 p->fd = fdset_remove(fds, fd);
1833 } else if (streq(key, "mqueue")) {
1837 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1838 log_debug_unit(u->id, "Failed to parse mqueue value %s", value);
1841 LIST_FOREACH(port, p, s->ports)
1842 if (p->type == SOCKET_MQUEUE &&
1843 streq_ptr(p->path, value+skip))
1848 p->fd = fdset_remove(fds, fd);
1852 } else if (streq(key, "socket")) {
1853 int fd, type, skip = 0;
1856 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1857 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1860 LIST_FOREACH(port, p, s->ports)
1861 if (socket_address_is(&p->address, value+skip, type))
1866 p->fd = fdset_remove(fds, fd);
1870 } else if (streq(key, "netlink")) {
1874 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1875 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1878 LIST_FOREACH(port, p, s->ports)
1879 if (socket_address_is_netlink(&p->address, value+skip))
1884 p->fd = fdset_remove(fds, fd);
1888 log_debug_unit(UNIT(s)->id, "Unknown serialization key '%s'", key);
1893 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1894 Socket *s = SOCKET(u);
1899 LIST_FOREACH(port, p, s->ports) {
1903 if (p->type != SOCKET_SOCKET)
1909 FDSET_FOREACH(fd, fds, i) {
1910 if (socket_address_matches_fd(&p->address, fd)) {
1911 p->fd = fdset_remove(fds, fd);
1912 s->deserialized_state = SOCKET_LISTENING;
1921 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1924 return state_translation_table[SOCKET(u)->state];
1927 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1930 return socket_state_to_string(SOCKET(u)->state);
1933 const char* socket_port_type_to_string(SocketPort *p) {
1941 switch (p->address.type) {
1949 case SOCK_SEQPACKET:
1950 return "SequentialPacket";
1953 if (socket_address_family(&p->address) == AF_NETLINK)
1960 case SOCKET_SPECIAL:
1964 return "MessageQueue";
1974 _pure_ static bool socket_check_gc(Unit *u) {
1975 Socket *s = SOCKET(u);
1979 return s->n_connections > 0;
1982 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1983 SocketPort *p = userdata;
1989 if (p->socket->state != SOCKET_LISTENING)
1992 log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
1994 if (revents != EPOLLIN) {
1996 if (revents & EPOLLHUP)
1997 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.",
1998 UNIT(p->socket)->id);
2000 log_error_unit(UNIT(p->socket)->id, "%s: Got unexpected poll event (0x%x) on socket.",
2001 UNIT(p->socket)->id, revents);
2006 if (p->socket->accept &&
2007 p->type == SOCKET_SOCKET &&
2008 socket_address_can_accept(&p->address)) {
2012 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2018 log_error_unit(UNIT(p->socket)->id,
2019 "Failed to accept socket: %m");
2026 socket_apply_socket_options(p->socket, cfd);
2029 socket_enter_running(p->socket, cfd);
2033 socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2037 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2038 Socket *s = SOCKET(u);
2044 if (pid != s->control_pid)
2049 if (is_clean_exit(code, status, NULL))
2051 else if (code == CLD_EXITED)
2052 f = SOCKET_FAILURE_EXIT_CODE;
2053 else if (code == CLD_KILLED)
2054 f = SOCKET_FAILURE_SIGNAL;
2055 else if (code == CLD_DUMPED)
2056 f = SOCKET_FAILURE_CORE_DUMP;
2058 assert_not_reached("Unknown code");
2060 if (s->control_command) {
2061 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2063 if (s->control_command->ignore)
2067 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2069 "%s control process exited, code=%s status=%i",
2070 u->id, sigchld_code_to_string(code), status);
2072 if (f != SOCKET_SUCCESS)
2075 if (s->control_command &&
2076 s->control_command->command_next &&
2077 f == SOCKET_SUCCESS) {
2079 log_debug_unit(u->id,
2080 "%s running next command for state %s",
2081 u->id, socket_state_to_string(s->state));
2084 s->control_command = NULL;
2085 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2087 /* No further commands for this step, so let's figure
2088 * out what to do next */
2090 log_debug_unit(u->id,
2091 "%s got final SIGCHLD for state %s",
2092 u->id, socket_state_to_string(s->state));
2096 case SOCKET_START_PRE:
2097 if (f == SOCKET_SUCCESS)
2098 socket_enter_start_post(s);
2100 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2103 case SOCKET_START_POST:
2104 if (f == SOCKET_SUCCESS)
2105 socket_enter_listening(s);
2107 socket_enter_stop_pre(s, f);
2110 case SOCKET_STOP_PRE:
2111 case SOCKET_STOP_PRE_SIGTERM:
2112 case SOCKET_STOP_PRE_SIGKILL:
2113 socket_enter_stop_post(s, f);
2116 case SOCKET_STOP_POST:
2117 case SOCKET_FINAL_SIGTERM:
2118 case SOCKET_FINAL_SIGKILL:
2119 socket_enter_dead(s, f);
2123 assert_not_reached("Uh, control process died at wrong time.");
2127 /* Notify clients about changed exit status */
2128 unit_add_to_dbus_queue(u);
2131 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2132 Socket *s = SOCKET(userdata);
2135 assert(s->timer_event_source == source);
2139 case SOCKET_START_PRE:
2140 log_warning_unit(UNIT(s)->id,
2141 "%s starting timed out. Terminating.", UNIT(s)->id);
2142 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2145 case SOCKET_START_POST:
2146 log_warning_unit(UNIT(s)->id,
2147 "%s starting timed out. Stopping.", UNIT(s)->id);
2148 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2151 case SOCKET_STOP_PRE:
2152 log_warning_unit(UNIT(s)->id,
2153 "%s stopping timed out. Terminating.", UNIT(s)->id);
2154 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2157 case SOCKET_STOP_PRE_SIGTERM:
2158 if (s->kill_context.send_sigkill) {
2159 log_warning_unit(UNIT(s)->id,
2160 "%s stopping timed out. Killing.", UNIT(s)->id);
2161 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2163 log_warning_unit(UNIT(s)->id,
2164 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2166 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2170 case SOCKET_STOP_PRE_SIGKILL:
2171 log_warning_unit(UNIT(s)->id,
2172 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2173 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2176 case SOCKET_STOP_POST:
2177 log_warning_unit(UNIT(s)->id,
2178 "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2179 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2182 case SOCKET_FINAL_SIGTERM:
2183 if (s->kill_context.send_sigkill) {
2184 log_warning_unit(UNIT(s)->id,
2185 "%s stopping timed out (2). Killing.", UNIT(s)->id);
2186 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2188 log_warning_unit(UNIT(s)->id,
2189 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2191 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2195 case SOCKET_FINAL_SIGKILL:
2196 log_warning_unit(UNIT(s)->id,
2197 "%s still around after SIGKILL (2). Entering failed mode.",
2199 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2203 assert_not_reached("Timeout at wrong time.");
2209 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2218 /* Called from the service code for requesting our fds */
2221 LIST_FOREACH(port, p, s->ports)
2231 if (!(rfds = new(int, rn_fds)))
2235 LIST_FOREACH(port, p, s->ports)
2239 assert(k == rn_fds);
2247 static void socket_reset_failed(Unit *u) {
2248 Socket *s = SOCKET(u);
2252 if (s->state == SOCKET_FAILED)
2253 socket_set_state(s, SOCKET_DEAD);
2255 s->result = SOCKET_SUCCESS;
2258 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2261 /* The service is dead. Dang!
2263 * This is strictly for one-instance-for-all-connections
2266 if (s->state == SOCKET_RUNNING) {
2267 log_debug_unit(UNIT(s)->id, "%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2268 if (failed_permanent)
2269 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2271 socket_enter_listening(s);
2275 void socket_connection_unref(Socket *s) {
2278 /* The service is dead. Yay!
2280 * This is strictly for one-instance-per-connection
2283 assert(s->n_connections > 0);
2286 log_debug_unit(UNIT(s)->id, "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2289 static void socket_trigger_notify(Unit *u, Unit *other) {
2290 Socket *s = SOCKET(u);
2296 /* Don't propagate state changes from the service if we are
2297 already down or accepting connections */
2298 if ((s->state != SOCKET_RUNNING &&
2299 s->state != SOCKET_LISTENING) ||
2303 if (other->load_state != UNIT_LOADED ||
2304 other->type != UNIT_SERVICE)
2307 se = SERVICE(other);
2309 if (se->state == SERVICE_FAILED)
2310 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2312 if (se->state == SERVICE_DEAD ||
2313 se->state == SERVICE_STOP ||
2314 se->state == SERVICE_STOP_SIGTERM ||
2315 se->state == SERVICE_STOP_SIGKILL ||
2316 se->state == SERVICE_STOP_POST ||
2317 se->state == SERVICE_FINAL_SIGTERM ||
2318 se->state == SERVICE_FINAL_SIGKILL ||
2319 se->state == SERVICE_AUTO_RESTART)
2320 socket_notify_service_dead(s, false);
2322 if (se->state == SERVICE_RUNNING)
2323 socket_set_state(s, SOCKET_RUNNING);
2326 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2327 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2330 static int socket_get_timeout(Unit *u, uint64_t *timeout) {
2331 Socket *s = SOCKET(u);
2334 if (!s->timer_event_source)
2337 r = sd_event_source_get_time(s->timer_event_source, timeout);
2344 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2345 [SOCKET_DEAD] = "dead",
2346 [SOCKET_START_PRE] = "start-pre",
2347 [SOCKET_START_POST] = "start-post",
2348 [SOCKET_LISTENING] = "listening",
2349 [SOCKET_RUNNING] = "running",
2350 [SOCKET_STOP_PRE] = "stop-pre",
2351 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2352 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2353 [SOCKET_STOP_POST] = "stop-post",
2354 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2355 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2356 [SOCKET_FAILED] = "failed"
2359 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2361 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2362 [SOCKET_EXEC_START_PRE] = "StartPre",
2363 [SOCKET_EXEC_START_POST] = "StartPost",
2364 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2365 [SOCKET_EXEC_STOP_POST] = "StopPost"
2368 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2370 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2371 [SOCKET_SUCCESS] = "success",
2372 [SOCKET_FAILURE_RESOURCES] = "resources",
2373 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2374 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2375 [SOCKET_FAILURE_SIGNAL] = "signal",
2376 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2377 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2380 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2382 const UnitVTable socket_vtable = {
2383 .object_size = sizeof(Socket),
2384 .exec_context_offset = offsetof(Socket, exec_context),
2385 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2386 .kill_context_offset = offsetof(Socket, kill_context),
2387 .exec_runtime_offset = offsetof(Socket, exec_runtime),
2393 .private_section = "Socket",
2395 .init = socket_init,
2396 .done = socket_done,
2397 .load = socket_load,
2399 .coldplug = socket_coldplug,
2401 .dump = socket_dump,
2403 .start = socket_start,
2404 .stop = socket_stop,
2406 .kill = socket_kill,
2408 .get_timeout = socket_get_timeout,
2410 .serialize = socket_serialize,
2411 .deserialize_item = socket_deserialize_item,
2412 .distribute_fds = socket_distribute_fds,
2414 .active_state = socket_active_state,
2415 .sub_state_to_string = socket_sub_state_to_string,
2417 .check_gc = socket_check_gc,
2419 .sigchld_event = socket_sigchld_event,
2421 .trigger_notify = socket_trigger_notify,
2423 .reset_failed = socket_reset_failed,
2425 .bus_interface = "org.freedesktop.systemd1.Socket",
2426 .bus_vtable = bus_socket_vtable,
2427 .bus_set_property = bus_socket_set_property,
2428 .bus_commit_properties = bus_socket_commit_properties,
2430 .status_message_formats = {
2431 /*.starting_stopping = {
2432 [0] = "Starting socket %s...",
2433 [1] = "Stopping socket %s...",
2435 .finished_start_job = {
2436 [JOB_DONE] = "Listening on %s.",
2437 [JOB_FAILED] = "Failed to listen on %s.",
2438 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2439 [JOB_TIMEOUT] = "Timed out starting %s.",
2441 .finished_stop_job = {
2442 [JOB_DONE] = "Closed %s.",
2443 [JOB_FAILED] = "Failed stopping %s.",
2444 [JOB_TIMEOUT] = "Timed out stopping %s.",