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);
668 "%u-"PID_FMT"-"UID_FMT,
669 nr, ucred.pid, ucred.uid) < 0)
671 } else if (k == -ENODATA) {
672 /* This handles the case where somebody is
673 * connecting from another pid/uid namespace
674 * (e.g. from outside of our container). */
686 assert_not_reached("Unhandled socket type.");
693 static void socket_close_fds(Socket *s) {
698 LIST_FOREACH(port, p, s->ports) {
700 p->event_source = sd_event_source_unref(p->event_source);
705 p->fd = safe_close(p->fd);
707 /* One little note: we should never delete any sockets
708 * in the file system here! After all some other
709 * process we spawned might still have a reference of
710 * this fd and wants to continue to use it. Therefore
711 * we delete sockets in the file system before we
712 * create a new one, not after we stopped using
717 static void socket_apply_socket_options(Socket *s, int fd) {
722 int b = s->keep_alive;
723 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
724 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
729 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
730 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
735 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
736 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
741 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
742 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
745 if (s->priority >= 0)
746 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
747 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
749 if (s->receive_buffer > 0) {
750 int value = (int) s->receive_buffer;
752 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
754 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
755 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
756 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
759 if (s->send_buffer > 0) {
760 int value = (int) s->send_buffer;
761 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
762 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
763 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
767 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
768 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
771 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
772 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
774 if (s->ip_ttl >= 0) {
777 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
779 if (socket_ipv6_is_supported())
780 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
783 errno = EAFNOSUPPORT;
787 log_warning_unit(UNIT(s)->id,
788 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
791 if (s->tcp_congestion)
792 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
793 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
796 int b = s->reuse_port;
797 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)) < 0)
798 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
802 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
803 log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
806 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
807 log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
810 static void socket_apply_fifo_options(Socket *s, int fd) {
814 if (s->pipe_size > 0)
815 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
816 log_warning_unit(UNIT(s)->id,
820 if (smack_label_fd(fd, s->smack) < 0)
821 log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
824 static int fifo_address_create(
826 mode_t directory_mode,
837 mkdir_parents_label(path, directory_mode);
839 r = label_context_set(path, S_IFIFO);
843 /* Enforce the right access mode for the fifo */
844 old_mask = umask(~ socket_mode);
846 /* Include the original umask in our mask */
847 umask(~socket_mode | old_mask);
849 r = mkfifo(path, socket_mode);
852 if (r < 0 && errno != EEXIST) {
857 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
862 label_context_clear();
864 if (fstat(fd, &st) < 0) {
869 if (!S_ISFIFO(st.st_mode) ||
870 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
871 st.st_uid != getuid() ||
872 st.st_gid != getgid()) {
882 label_context_clear();
888 static int special_address_create(
898 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
903 if (fstat(fd, &st) < 0) {
908 /* Check whether this is a /proc, /sys or /dev file or char device */
909 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
923 static int mq_address_create(
933 struct mq_attr _attr, *attr = NULL;
938 if (maxmsg > 0 && msgsize > 0) {
940 _attr.mq_flags = O_NONBLOCK;
941 _attr.mq_maxmsg = maxmsg;
942 _attr.mq_msgsize = msgsize;
946 /* Enforce the right access mode for the mq */
947 old_mask = umask(~ mq_mode);
949 /* Include the original umask in our mask */
950 umask(~mq_mode | old_mask);
952 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
960 if (fstat(fd, &st) < 0) {
965 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
966 st.st_uid != getuid() ||
967 st.st_gid != getgid()) {
981 static int socket_open_fds(Socket *s) {
985 bool know_label = false;
989 LIST_FOREACH(port, p, s->ports) {
994 if (p->type == SOCKET_SOCKET) {
998 if ((r = socket_instantiate_service(s)) < 0)
1001 if (UNIT_ISSET(s->service) &&
1002 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1003 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1014 r = socket_address_listen(
1016 SOCK_CLOEXEC|SOCK_NONBLOCK,
1029 socket_apply_socket_options(s, p->fd);
1031 } else if (p->type == SOCKET_SPECIAL) {
1033 r = special_address_create(
1039 } else if (p->type == SOCKET_FIFO) {
1041 r = fifo_address_create(
1049 socket_apply_fifo_options(s, p->fd);
1050 } else if (p->type == SOCKET_MQUEUE) {
1052 r = mq_address_create(
1061 assert_not_reached("Unknown port type");
1068 socket_close_fds(s);
1073 static void socket_unwatch_fds(Socket *s) {
1079 LIST_FOREACH(port, p, s->ports) {
1083 if (p->event_source) {
1084 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_OFF);
1086 log_debug_unit(UNIT(s)->id, "Failed to disable event source.");
1091 static int socket_watch_fds(Socket *s) {
1097 LIST_FOREACH(port, p, s->ports) {
1101 if (p->event_source)
1102 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1104 r = sd_event_add_io(UNIT(s)->manager->event, &p->event_source, p->fd, EPOLLIN, socket_dispatch_io, p);
1107 log_warning_unit(UNIT(s)->id, "Failed to watch listening fds: %s", strerror(-r));
1115 socket_unwatch_fds(s);
1119 static void socket_set_state(Socket *s, SocketState state) {
1120 SocketState old_state;
1123 old_state = s->state;
1126 if (state != SOCKET_START_PRE &&
1127 state != SOCKET_START_POST &&
1128 state != SOCKET_STOP_PRE &&
1129 state != SOCKET_STOP_PRE_SIGTERM &&
1130 state != SOCKET_STOP_PRE_SIGKILL &&
1131 state != SOCKET_STOP_POST &&
1132 state != SOCKET_FINAL_SIGTERM &&
1133 state != SOCKET_FINAL_SIGKILL) {
1135 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1136 socket_unwatch_control_pid(s);
1137 s->control_command = NULL;
1138 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1141 if (state != SOCKET_LISTENING)
1142 socket_unwatch_fds(s);
1144 if (state != SOCKET_START_POST &&
1145 state != SOCKET_LISTENING &&
1146 state != SOCKET_RUNNING &&
1147 state != SOCKET_STOP_PRE &&
1148 state != SOCKET_STOP_PRE_SIGTERM &&
1149 state != SOCKET_STOP_PRE_SIGKILL)
1150 socket_close_fds(s);
1152 if (state != old_state)
1153 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s",
1154 UNIT(s)->id, socket_state_to_string(old_state), socket_state_to_string(state));
1156 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1159 static int socket_coldplug(Unit *u) {
1160 Socket *s = SOCKET(u);
1164 assert(s->state == SOCKET_DEAD);
1166 if (s->deserialized_state == s->state)
1169 if (s->deserialized_state == SOCKET_START_PRE ||
1170 s->deserialized_state == SOCKET_START_POST ||
1171 s->deserialized_state == SOCKET_STOP_PRE ||
1172 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1173 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1174 s->deserialized_state == SOCKET_STOP_POST ||
1175 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1176 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1178 if (s->control_pid <= 0)
1181 r = unit_watch_pid(UNIT(s), s->control_pid);
1185 r = socket_arm_timer(s);
1190 if (s->deserialized_state == SOCKET_START_POST ||
1191 s->deserialized_state == SOCKET_LISTENING ||
1192 s->deserialized_state == SOCKET_RUNNING ||
1193 s->deserialized_state == SOCKET_STOP_PRE ||
1194 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1195 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL) {
1196 r = socket_open_fds(s);
1201 if (s->deserialized_state == SOCKET_LISTENING) {
1202 r = socket_watch_fds(s);
1207 socket_set_state(s, s->deserialized_state);
1211 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1220 unit_realize_cgroup(UNIT(s));
1222 r = unit_setup_exec_runtime(UNIT(s));
1226 r = socket_arm_timer(s);
1230 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1238 UNIT(s)->manager->environment,
1242 UNIT(s)->manager->confirm_spawn,
1243 UNIT(s)->manager->cgroup_supported,
1244 UNIT(s)->cgroup_path,
1245 manager_get_runtime_prefix(UNIT(s)->manager),
1256 r = unit_watch_pid(UNIT(s), pid);
1258 /* FIXME: we need to do something here */
1266 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1271 static void socket_enter_dead(Socket *s, SocketResult f) {
1274 if (f != SOCKET_SUCCESS)
1277 exec_runtime_destroy(s->exec_runtime);
1278 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1280 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1282 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1285 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1287 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1291 if (f != SOCKET_SUCCESS)
1294 socket_unwatch_control_pid(s);
1296 s->control_command_id = SOCKET_EXEC_STOP_POST;
1298 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1299 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1302 socket_set_state(s, SOCKET_STOP_POST);
1304 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1309 log_warning_unit(UNIT(s)->id,
1310 "%s failed to run 'stop-post' task: %s",
1311 UNIT(s)->id, strerror(-r));
1312 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1315 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1320 if (f != SOCKET_SUCCESS)
1323 r = unit_kill_context(
1326 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1334 r = socket_arm_timer(s);
1338 socket_set_state(s, state);
1339 } else if (state == SOCKET_STOP_PRE_SIGTERM)
1340 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_SUCCESS);
1341 else if (state == SOCKET_STOP_PRE_SIGKILL)
1342 socket_enter_stop_post(s, SOCKET_SUCCESS);
1343 else if (state == SOCKET_FINAL_SIGTERM)
1344 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
1346 socket_enter_dead(s, SOCKET_SUCCESS);
1351 log_warning_unit(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1353 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1354 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1356 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1359 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1363 if (f != SOCKET_SUCCESS)
1366 socket_unwatch_control_pid(s);
1368 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1370 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1371 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1374 socket_set_state(s, SOCKET_STOP_PRE);
1376 socket_enter_stop_post(s, SOCKET_SUCCESS);
1381 log_warning_unit(UNIT(s)->id, "%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1382 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1385 static void socket_enter_listening(Socket *s) {
1389 r = socket_watch_fds(s);
1391 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1395 socket_set_state(s, SOCKET_LISTENING);
1399 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1402 static void socket_enter_start_post(Socket *s) {
1406 r = socket_open_fds(s);
1408 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1412 socket_unwatch_control_pid(s);
1414 s->control_command_id = SOCKET_EXEC_START_POST;
1416 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1417 r = socket_spawn(s, s->control_command, &s->control_pid);
1419 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1423 socket_set_state(s, SOCKET_START_POST);
1425 socket_enter_listening(s);
1430 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1433 static void socket_enter_start_pre(Socket *s) {
1437 socket_unwatch_control_pid(s);
1439 s->control_command_id = SOCKET_EXEC_START_PRE;
1441 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1442 r = socket_spawn(s, s->control_command, &s->control_pid);
1446 socket_set_state(s, SOCKET_START_PRE);
1448 socket_enter_start_post(s);
1453 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1454 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1457 static void socket_enter_running(Socket *s, int cfd) {
1458 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1463 /* We don't take connections anymore if we are supposed to
1464 * shut down anyway */
1465 if (unit_stop_pending(UNIT(s))) {
1467 log_debug_unit(UNIT(s)->id, "Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1472 /* Flush all sockets by closing and reopening them */
1473 socket_close_fds(s);
1475 r = socket_open_fds(s);
1477 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1478 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1482 r = socket_watch_fds(s);
1484 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1485 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1495 bool pending = false;
1497 /* If there's already a start pending don't bother to
1499 SET_FOREACH(other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1500 if (unit_active_or_pending(other)) {
1506 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1511 socket_set_state(s, SOCKET_RUNNING);
1513 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1516 if (s->n_connections >= s->max_connections) {
1517 log_warning_unit(UNIT(s)->id, "%s: Too many incoming connections (%u)", UNIT(s)->id, s->n_connections);
1522 r = socket_instantiate_service(s);
1526 r = instance_from_socket(cfd, s->n_accepted, &instance);
1531 /* ENOTCONN is legitimate if TCP RST was received.
1532 * This connection is over, but the socket unit lives on. */
1537 prefix = unit_name_to_prefix(UNIT(s)->id);
1543 name = unit_name_build(prefix, instance, ".service");
1549 r = unit_add_name(UNIT_DEREF(s->service), name);
1553 service = SERVICE(UNIT_DEREF(s->service));
1554 unit_ref_unset(&s->service);
1557 UNIT(service)->no_gc = false;
1559 unit_choose_id(UNIT(service), name);
1561 r = service_set_socket_fd(service, cfd, s);
1566 s->n_connections ++;
1568 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1572 /* Notify clients about changed counters */
1573 unit_add_to_dbus_queue(UNIT(s));
1579 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",
1580 UNIT(s)->id, cfd >= 0 ? "template" : "non-template",
1581 bus_error_message(&error, r));
1583 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1587 static void socket_run_next(Socket *s) {
1591 assert(s->control_command);
1592 assert(s->control_command->command_next);
1594 socket_unwatch_control_pid(s);
1596 s->control_command = s->control_command->command_next;
1598 r = socket_spawn(s, s->control_command, &s->control_pid);
1605 log_warning_unit(UNIT(s)->id, "%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1607 if (s->state == SOCKET_START_POST)
1608 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1609 else if (s->state == SOCKET_STOP_POST)
1610 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1612 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1615 static int socket_start(Unit *u) {
1616 Socket *s = SOCKET(u);
1620 /* We cannot fulfill this request right now, try again later
1622 if (s->state == SOCKET_STOP_PRE ||
1623 s->state == SOCKET_STOP_PRE_SIGKILL ||
1624 s->state == SOCKET_STOP_PRE_SIGTERM ||
1625 s->state == SOCKET_STOP_POST ||
1626 s->state == SOCKET_FINAL_SIGTERM ||
1627 s->state == SOCKET_FINAL_SIGKILL)
1630 if (s->state == SOCKET_START_PRE ||
1631 s->state == SOCKET_START_POST)
1634 /* Cannot run this without the service being around */
1635 if (UNIT_ISSET(s->service)) {
1638 service = SERVICE(UNIT_DEREF(s->service));
1640 if (UNIT(service)->load_state != UNIT_LOADED) {
1641 log_error_unit(u->id, "Socket service %s not loaded, refusing.", UNIT(service)->id);
1645 /* If the service is already active we cannot start the
1647 if (service->state != SERVICE_DEAD &&
1648 service->state != SERVICE_FAILED &&
1649 service->state != SERVICE_AUTO_RESTART) {
1650 log_error_unit(u->id, "Socket service %s already active, refusing.", UNIT(service)->id);
1654 #ifdef HAVE_SYSV_COMPAT
1655 if (service->is_sysv) {
1656 log_error_unit(u->id,
1657 "Using SysV services for socket activation is not supported. Refusing.");
1663 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1665 s->result = SOCKET_SUCCESS;
1666 socket_enter_start_pre(s);
1671 static int socket_stop(Unit *u) {
1672 Socket *s = SOCKET(u);
1677 if (s->state == SOCKET_STOP_PRE ||
1678 s->state == SOCKET_STOP_PRE_SIGTERM ||
1679 s->state == SOCKET_STOP_PRE_SIGKILL ||
1680 s->state == SOCKET_STOP_POST ||
1681 s->state == SOCKET_FINAL_SIGTERM ||
1682 s->state == SOCKET_FINAL_SIGKILL)
1685 /* If there's already something running we go directly into
1687 if (s->state == SOCKET_START_PRE ||
1688 s->state == SOCKET_START_POST) {
1689 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1693 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1695 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1699 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1700 Socket *s = SOCKET(u);
1708 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1709 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1710 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1712 if (s->control_pid > 0)
1713 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1715 if (s->control_command_id >= 0)
1716 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1718 LIST_FOREACH(port, p, s->ports) {
1724 copy = fdset_put_dup(fds, p->fd);
1728 if (p->type == SOCKET_SOCKET) {
1729 _cleanup_free_ char *t = NULL;
1731 r = socket_address_print(&p->address, &t);
1735 if (socket_address_family(&p->address) == AF_NETLINK)
1736 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1738 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1740 } else if (p->type == SOCKET_SPECIAL)
1741 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1742 else if (p->type == SOCKET_MQUEUE)
1743 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1745 assert(p->type == SOCKET_FIFO);
1746 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1753 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1754 Socket *s = SOCKET(u);
1760 if (streq(key, "state")) {
1763 state = socket_state_from_string(value);
1765 log_debug_unit(u->id, "Failed to parse state value %s", value);
1767 s->deserialized_state = state;
1768 } else if (streq(key, "result")) {
1771 f = socket_result_from_string(value);
1773 log_debug_unit(u->id, "Failed to parse result value %s", value);
1774 else if (f != SOCKET_SUCCESS)
1777 } else if (streq(key, "n-accepted")) {
1780 if (safe_atou(value, &k) < 0)
1781 log_debug_unit(u->id, "Failed to parse n-accepted value %s", value);
1784 } else if (streq(key, "control-pid")) {
1787 if (parse_pid(value, &pid) < 0)
1788 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1790 s->control_pid = pid;
1791 } else if (streq(key, "control-command")) {
1792 SocketExecCommand id;
1794 id = socket_exec_command_from_string(value);
1796 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1798 s->control_command_id = id;
1799 s->control_command = s->exec_command[id];
1801 } else if (streq(key, "fifo")) {
1805 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1806 log_debug_unit(u->id, "Failed to parse fifo value %s", value);
1809 LIST_FOREACH(port, p, s->ports)
1810 if (p->type == SOCKET_FIFO &&
1811 streq_ptr(p->path, value+skip))
1816 p->fd = fdset_remove(fds, fd);
1820 } else if (streq(key, "special")) {
1824 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1825 log_debug_unit(u->id, "Failed to parse special value %s", value);
1828 LIST_FOREACH(port, p, s->ports)
1829 if (p->type == SOCKET_SPECIAL &&
1830 streq_ptr(p->path, value+skip))
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 p->fd = fdset_remove(fds, fd);
1858 } else if (streq(key, "socket")) {
1859 int fd, type, skip = 0;
1862 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1863 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1866 LIST_FOREACH(port, p, s->ports)
1867 if (socket_address_is(&p->address, value+skip, type))
1872 p->fd = fdset_remove(fds, fd);
1876 } else if (streq(key, "netlink")) {
1880 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1881 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1884 LIST_FOREACH(port, p, s->ports)
1885 if (socket_address_is_netlink(&p->address, value+skip))
1890 p->fd = fdset_remove(fds, fd);
1894 log_debug_unit(UNIT(s)->id, "Unknown serialization key '%s'", key);
1899 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1900 Socket *s = SOCKET(u);
1905 LIST_FOREACH(port, p, s->ports) {
1909 if (p->type != SOCKET_SOCKET)
1915 FDSET_FOREACH(fd, fds, i) {
1916 if (socket_address_matches_fd(&p->address, fd)) {
1917 p->fd = fdset_remove(fds, fd);
1918 s->deserialized_state = SOCKET_LISTENING;
1927 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1930 return state_translation_table[SOCKET(u)->state];
1933 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1936 return socket_state_to_string(SOCKET(u)->state);
1939 const char* socket_port_type_to_string(SocketPort *p) {
1947 switch (p->address.type) {
1955 case SOCK_SEQPACKET:
1956 return "SequentialPacket";
1959 if (socket_address_family(&p->address) == AF_NETLINK)
1966 case SOCKET_SPECIAL:
1970 return "MessageQueue";
1980 _pure_ static bool socket_check_gc(Unit *u) {
1981 Socket *s = SOCKET(u);
1985 return s->n_connections > 0;
1988 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1989 SocketPort *p = userdata;
1995 if (p->socket->state != SOCKET_LISTENING)
1998 log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
2000 if (revents != EPOLLIN) {
2002 if (revents & EPOLLHUP)
2003 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.",
2004 UNIT(p->socket)->id);
2006 log_error_unit(UNIT(p->socket)->id, "%s: Got unexpected poll event (0x%x) on socket.",
2007 UNIT(p->socket)->id, revents);
2012 if (p->socket->accept &&
2013 p->type == SOCKET_SOCKET &&
2014 socket_address_can_accept(&p->address)) {
2018 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2024 log_error_unit(UNIT(p->socket)->id,
2025 "Failed to accept socket: %m");
2032 socket_apply_socket_options(p->socket, cfd);
2035 socket_enter_running(p->socket, cfd);
2039 socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2043 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2044 Socket *s = SOCKET(u);
2050 if (pid != s->control_pid)
2055 if (is_clean_exit(code, status, NULL))
2057 else if (code == CLD_EXITED)
2058 f = SOCKET_FAILURE_EXIT_CODE;
2059 else if (code == CLD_KILLED)
2060 f = SOCKET_FAILURE_SIGNAL;
2061 else if (code == CLD_DUMPED)
2062 f = SOCKET_FAILURE_CORE_DUMP;
2064 assert_not_reached("Unknown code");
2066 if (s->control_command) {
2067 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2069 if (s->control_command->ignore)
2073 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2075 "%s control process exited, code=%s status=%i",
2076 u->id, sigchld_code_to_string(code), status);
2078 if (f != SOCKET_SUCCESS)
2081 if (s->control_command &&
2082 s->control_command->command_next &&
2083 f == SOCKET_SUCCESS) {
2085 log_debug_unit(u->id,
2086 "%s running next command for state %s",
2087 u->id, socket_state_to_string(s->state));
2090 s->control_command = NULL;
2091 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2093 /* No further commands for this step, so let's figure
2094 * out what to do next */
2096 log_debug_unit(u->id,
2097 "%s got final SIGCHLD for state %s",
2098 u->id, socket_state_to_string(s->state));
2102 case SOCKET_START_PRE:
2103 if (f == SOCKET_SUCCESS)
2104 socket_enter_start_post(s);
2106 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2109 case SOCKET_START_POST:
2110 if (f == SOCKET_SUCCESS)
2111 socket_enter_listening(s);
2113 socket_enter_stop_pre(s, f);
2116 case SOCKET_STOP_PRE:
2117 case SOCKET_STOP_PRE_SIGTERM:
2118 case SOCKET_STOP_PRE_SIGKILL:
2119 socket_enter_stop_post(s, f);
2122 case SOCKET_STOP_POST:
2123 case SOCKET_FINAL_SIGTERM:
2124 case SOCKET_FINAL_SIGKILL:
2125 socket_enter_dead(s, f);
2129 assert_not_reached("Uh, control process died at wrong time.");
2133 /* Notify clients about changed exit status */
2134 unit_add_to_dbus_queue(u);
2137 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2138 Socket *s = SOCKET(userdata);
2141 assert(s->timer_event_source == source);
2145 case SOCKET_START_PRE:
2146 log_warning_unit(UNIT(s)->id,
2147 "%s starting timed out. Terminating.", UNIT(s)->id);
2148 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2151 case SOCKET_START_POST:
2152 log_warning_unit(UNIT(s)->id,
2153 "%s starting timed out. Stopping.", UNIT(s)->id);
2154 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2157 case SOCKET_STOP_PRE:
2158 log_warning_unit(UNIT(s)->id,
2159 "%s stopping timed out. Terminating.", UNIT(s)->id);
2160 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2163 case SOCKET_STOP_PRE_SIGTERM:
2164 if (s->kill_context.send_sigkill) {
2165 log_warning_unit(UNIT(s)->id,
2166 "%s stopping timed out. Killing.", UNIT(s)->id);
2167 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2169 log_warning_unit(UNIT(s)->id,
2170 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2172 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2176 case SOCKET_STOP_PRE_SIGKILL:
2177 log_warning_unit(UNIT(s)->id,
2178 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2179 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2182 case SOCKET_STOP_POST:
2183 log_warning_unit(UNIT(s)->id,
2184 "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2185 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2188 case SOCKET_FINAL_SIGTERM:
2189 if (s->kill_context.send_sigkill) {
2190 log_warning_unit(UNIT(s)->id,
2191 "%s stopping timed out (2). Killing.", UNIT(s)->id);
2192 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2194 log_warning_unit(UNIT(s)->id,
2195 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2197 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2201 case SOCKET_FINAL_SIGKILL:
2202 log_warning_unit(UNIT(s)->id,
2203 "%s still around after SIGKILL (2). Entering failed mode.",
2205 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2209 assert_not_reached("Timeout at wrong time.");
2215 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2224 /* Called from the service code for requesting our fds */
2227 LIST_FOREACH(port, p, s->ports)
2237 if (!(rfds = new(int, rn_fds)))
2241 LIST_FOREACH(port, p, s->ports)
2245 assert(k == rn_fds);
2253 static void socket_reset_failed(Unit *u) {
2254 Socket *s = SOCKET(u);
2258 if (s->state == SOCKET_FAILED)
2259 socket_set_state(s, SOCKET_DEAD);
2261 s->result = SOCKET_SUCCESS;
2264 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2267 /* The service is dead. Dang!
2269 * This is strictly for one-instance-for-all-connections
2272 if (s->state == SOCKET_RUNNING) {
2273 log_debug_unit(UNIT(s)->id, "%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2274 if (failed_permanent)
2275 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2277 socket_enter_listening(s);
2281 void socket_connection_unref(Socket *s) {
2284 /* The service is dead. Yay!
2286 * This is strictly for one-instance-per-connection
2289 assert(s->n_connections > 0);
2292 log_debug_unit(UNIT(s)->id, "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2295 static void socket_trigger_notify(Unit *u, Unit *other) {
2296 Socket *s = SOCKET(u);
2302 /* Don't propagate state changes from the service if we are
2303 already down or accepting connections */
2304 if ((s->state != SOCKET_RUNNING &&
2305 s->state != SOCKET_LISTENING) ||
2309 if (other->load_state != UNIT_LOADED ||
2310 other->type != UNIT_SERVICE)
2313 se = SERVICE(other);
2315 if (se->state == SERVICE_FAILED)
2316 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2318 if (se->state == SERVICE_DEAD ||
2319 se->state == SERVICE_STOP ||
2320 se->state == SERVICE_STOP_SIGTERM ||
2321 se->state == SERVICE_STOP_SIGKILL ||
2322 se->state == SERVICE_STOP_POST ||
2323 se->state == SERVICE_FINAL_SIGTERM ||
2324 se->state == SERVICE_FINAL_SIGKILL ||
2325 se->state == SERVICE_AUTO_RESTART)
2326 socket_notify_service_dead(s, false);
2328 if (se->state == SERVICE_RUNNING)
2329 socket_set_state(s, SOCKET_RUNNING);
2332 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2333 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2336 static int socket_get_timeout(Unit *u, uint64_t *timeout) {
2337 Socket *s = SOCKET(u);
2340 if (!s->timer_event_source)
2343 r = sd_event_source_get_time(s->timer_event_source, timeout);
2350 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2351 [SOCKET_DEAD] = "dead",
2352 [SOCKET_START_PRE] = "start-pre",
2353 [SOCKET_START_POST] = "start-post",
2354 [SOCKET_LISTENING] = "listening",
2355 [SOCKET_RUNNING] = "running",
2356 [SOCKET_STOP_PRE] = "stop-pre",
2357 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2358 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2359 [SOCKET_STOP_POST] = "stop-post",
2360 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2361 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2362 [SOCKET_FAILED] = "failed"
2365 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2367 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2368 [SOCKET_EXEC_START_PRE] = "StartPre",
2369 [SOCKET_EXEC_START_POST] = "StartPost",
2370 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2371 [SOCKET_EXEC_STOP_POST] = "StopPost"
2374 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2376 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2377 [SOCKET_SUCCESS] = "success",
2378 [SOCKET_FAILURE_RESOURCES] = "resources",
2379 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2380 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2381 [SOCKET_FAILURE_SIGNAL] = "signal",
2382 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2383 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2386 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2388 const UnitVTable socket_vtable = {
2389 .object_size = sizeof(Socket),
2390 .exec_context_offset = offsetof(Socket, exec_context),
2391 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2392 .kill_context_offset = offsetof(Socket, kill_context),
2393 .exec_runtime_offset = offsetof(Socket, exec_runtime),
2399 .private_section = "Socket",
2401 .init = socket_init,
2402 .done = socket_done,
2403 .load = socket_load,
2405 .coldplug = socket_coldplug,
2407 .dump = socket_dump,
2409 .start = socket_start,
2410 .stop = socket_stop,
2412 .kill = socket_kill,
2414 .get_timeout = socket_get_timeout,
2416 .serialize = socket_serialize,
2417 .deserialize_item = socket_deserialize_item,
2418 .distribute_fds = socket_distribute_fds,
2420 .active_state = socket_active_state,
2421 .sub_state_to_string = socket_sub_state_to_string,
2423 .check_gc = socket_check_gc,
2425 .sigchld_event = socket_sigchld_event,
2427 .trigger_notify = socket_trigger_notify,
2429 .reset_failed = socket_reset_failed,
2431 .bus_interface = "org.freedesktop.systemd1.Socket",
2432 .bus_vtable = bus_socket_vtable,
2433 .bus_set_property = bus_socket_set_property,
2434 .bus_commit_properties = bus_socket_commit_properties,
2436 .status_message_formats = {
2437 /*.starting_stopping = {
2438 [0] = "Starting socket %s...",
2439 [1] = "Stopping socket %s...",
2441 .finished_start_job = {
2442 [JOB_DONE] = "Listening on %s.",
2443 [JOB_FAILED] = "Failed to listen on %s.",
2444 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2445 [JOB_TIMEOUT] = "Timed out starting %s.",
2447 .finished_stop_job = {
2448 [JOB_DONE] = "Closed %s.",
2449 [JOB_FAILED] = "Failed stopping %s.",
2450 [JOB_TIMEOUT] = "Timed out stopping %s.",