1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include <sys/types.h>
27 #include <sys/epoll.h>
29 #include <arpa/inet.h>
30 #include <netinet/tcp.h>
33 #include <attr/xattr.h>
38 #include "load-dropin.h"
39 #include "load-fragment.h"
42 #include "path-util.h"
43 #include "unit-name.h"
44 #include "unit-printf.h"
48 #include "exit-status.h"
50 #include "smack-util.h"
52 #include "bus-error.h"
53 #include "dbus-socket.h"
57 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
58 [SOCKET_DEAD] = UNIT_INACTIVE,
59 [SOCKET_START_PRE] = UNIT_ACTIVATING,
60 [SOCKET_START_POST] = UNIT_ACTIVATING,
61 [SOCKET_LISTENING] = UNIT_ACTIVE,
62 [SOCKET_RUNNING] = UNIT_ACTIVE,
63 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
64 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
65 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
66 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
67 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
68 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
69 [SOCKET_FAILED] = UNIT_FAILED
72 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
73 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
75 static void socket_init(Unit *u) {
76 Socket *s = SOCKET(u);
79 assert(u->load_state == UNIT_STUB);
81 s->backlog = SOMAXCONN;
82 s->timeout_usec = u->manager->default_timeout_start_usec;
83 s->directory_mode = 0755;
84 s->socket_mode = 0666;
86 s->max_connections = 64;
93 exec_context_init(&s->exec_context);
94 s->exec_context.std_output = u->manager->default_std_output;
95 s->exec_context.std_error = u->manager->default_std_error;
96 kill_context_init(&s->kill_context);
97 cgroup_context_init(&s->cgroup_context);
99 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
102 static void socket_unwatch_control_pid(Socket *s) {
105 if (s->control_pid <= 0)
108 unit_unwatch_pid(UNIT(s), s->control_pid);
112 void socket_free_ports(Socket *s) {
117 while ((p = s->ports)) {
118 LIST_REMOVE(port, s->ports, p);
120 sd_event_source_unref(p->event_source);
123 close_nointr_nofail(p->fd);
130 static void socket_done(Unit *u) {
131 Socket *s = SOCKET(u);
135 socket_free_ports(s);
137 cgroup_context_done(&s->cgroup_context);
138 exec_context_done(&s->exec_context);
139 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
140 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
141 s->control_command = NULL;
143 socket_unwatch_control_pid(s);
145 unit_ref_unset(&s->service);
147 free(s->tcp_congestion);
148 s->tcp_congestion = NULL;
150 free(s->bind_to_device);
151 s->bind_to_device = NULL;
154 free(s->smack_ip_in);
155 free(s->smack_ip_out);
157 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
160 static int socket_arm_timer(Socket *s) {
165 if (s->timeout_usec <= 0) {
166 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
170 if (s->timer_event_source) {
171 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec);
175 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
178 return sd_event_add_monotonic(UNIT(s)->manager->event, now(CLOCK_MONOTONIC) + s->timeout_usec, 0, socket_dispatch_timer, s, &s->timer_event_source);
181 static int socket_instantiate_service(Socket *s) {
188 /* This fills in s->service if it isn't filled in yet. For
189 * Accept=yes sockets we create the next connection service
190 * here. For Accept=no this is mostly a NOP since the service
191 * is figured out at load time anyway. */
193 if (UNIT_DEREF(s->service))
198 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
201 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
207 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
213 #ifdef HAVE_SYSV_COMPAT
214 if (SERVICE(u)->is_sysv) {
215 log_error("Using SysV services for socket activation is not supported. Refusing.");
221 unit_ref_set(&s->service, u);
223 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
226 static bool have_non_accept_socket(Socket *s) {
234 LIST_FOREACH(port, p, s->ports) {
236 if (p->type != SOCKET_SOCKET)
239 if (!socket_address_can_accept(&p->address))
246 static int socket_add_mount_links(Socket *s) {
252 LIST_FOREACH(port, p, s->ports) {
253 const char *path = NULL;
255 if (p->type == SOCKET_SOCKET)
256 path = socket_address_get_path(&p->address);
257 else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL)
263 r = unit_require_mounts_for(UNIT(s), path);
271 static int socket_add_device_link(Socket *s) {
276 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
279 t = strappenda("/sys/subsystem/net/devices/", s->bind_to_device);
280 return unit_add_node_link(UNIT(s), t, false);
283 static int socket_add_default_dependencies(Socket *s) {
287 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
291 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
292 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
297 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
300 _pure_ static bool socket_has_exec(Socket *s) {
304 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
305 if (s->exec_command[i])
311 static int socket_add_extras(Socket *s) {
317 if (have_non_accept_socket(s)) {
319 if (!UNIT_DEREF(s->service)) {
322 r = unit_load_related_unit(u, ".service", &x);
326 unit_ref_set(&s->service, x);
329 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
334 r = socket_add_mount_links(s);
338 r = socket_add_device_link(s);
342 r = unit_exec_context_defaults(u, &s->exec_context);
346 if (socket_has_exec(s)) {
347 r = unit_add_exec_dependencies(u, &s->exec_context);
351 r = unit_add_default_slice(u);
356 if (u->default_dependencies) {
357 r = socket_add_default_dependencies(s);
365 static int socket_verify(Socket *s) {
368 if (UNIT(s)->load_state != UNIT_LOADED)
372 log_error_unit(UNIT(s)->id, "%s lacks Listen setting. Refusing.", UNIT(s)->id);
376 if (s->accept && have_non_accept_socket(s)) {
377 log_error_unit(UNIT(s)->id, "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
382 if (s->accept && s->max_connections <= 0) {
383 log_error_unit(UNIT(s)->id, "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
387 if (s->accept && UNIT_DEREF(s->service)) {
388 log_error_unit(UNIT(s)->id, "Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
392 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
393 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
400 static int socket_load(Unit *u) {
401 Socket *s = SOCKET(u);
405 assert(u->load_state == UNIT_STUB);
407 r = unit_load_fragment_and_dropin(u);
411 if (u->load_state == UNIT_LOADED) {
412 /* This is a new unit? Then let's add in some extras */
413 r = socket_add_extras(s);
418 return socket_verify(s);
421 _const_ static const char* listen_lookup(int family, int type) {
423 if (family == AF_NETLINK)
424 return "ListenNetlink";
426 if (type == SOCK_STREAM)
427 return "ListenStream";
428 else if (type == SOCK_DGRAM)
429 return "ListenDatagram";
430 else if (type == SOCK_SEQPACKET)
431 return "ListenSequentialPacket";
433 assert_not_reached("Unknown socket type");
437 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
439 Socket *s = SOCKET(u);
446 prefix2 = strappenda(prefix, "\t");
449 "%sSocket State: %s\n"
451 "%sBindIPv6Only: %s\n"
453 "%sSocketMode: %04o\n"
454 "%sDirectoryMode: %04o\n"
457 "%sTransparent: %s\n"
459 "%sPassCredentials: %s\n"
460 "%sPassSecurity: %s\n"
461 "%sTCPCongestion: %s\n",
462 prefix, socket_state_to_string(s->state),
463 prefix, socket_result_to_string(s->result),
464 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
466 prefix, s->socket_mode,
467 prefix, s->directory_mode,
468 prefix, yes_no(s->keep_alive),
469 prefix, yes_no(s->free_bind),
470 prefix, yes_no(s->transparent),
471 prefix, yes_no(s->broadcast),
472 prefix, yes_no(s->pass_cred),
473 prefix, yes_no(s->pass_sec),
474 prefix, strna(s->tcp_congestion));
476 if (s->control_pid > 0)
478 "%sControl PID: %lu\n",
479 prefix, (unsigned long) s->control_pid);
481 if (s->bind_to_device)
483 "%sBindToDevice: %s\n",
484 prefix, s->bind_to_device);
489 "%sNConnections: %u\n"
490 "%sMaxConnections: %u\n",
491 prefix, s->n_accepted,
492 prefix, s->n_connections,
493 prefix, s->max_connections);
495 if (s->priority >= 0)
498 prefix, s->priority);
500 if (s->receive_buffer > 0)
502 "%sReceiveBuffer: %zu\n",
503 prefix, s->receive_buffer);
505 if (s->send_buffer > 0)
507 "%sSendBuffer: %zu\n",
508 prefix, s->send_buffer);
520 if (s->pipe_size > 0)
523 prefix, s->pipe_size);
530 if (s->mq_maxmsg > 0)
532 "%sMessageQueueMaxMessages: %li\n",
533 prefix, s->mq_maxmsg);
535 if (s->mq_msgsize > 0)
537 "%sMessageQueueMessageSize: %li\n",
538 prefix, s->mq_msgsize);
543 prefix, yes_no(s->reuse_port));
547 "%sSmackLabel: %s\n",
552 "%sSmackLabelIPIn: %s\n",
553 prefix, s->smack_ip_in);
557 "%sSmackLabelIPOut: %s\n",
558 prefix, s->smack_ip_out);
560 LIST_FOREACH(port, p, s->ports) {
562 if (p->type == SOCKET_SOCKET) {
567 if ((r = socket_address_print(&p->address, &k)) < 0)
572 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
574 } else if (p->type == SOCKET_SPECIAL)
575 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
576 else if (p->type == SOCKET_MQUEUE)
577 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
579 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
582 exec_context_dump(&s->exec_context, f, prefix);
583 kill_context_dump(&s->kill_context, f, prefix);
585 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
586 if (!s->exec_command[c])
589 fprintf(f, "%s-> %s:\n",
590 prefix, socket_exec_command_to_string(c));
592 exec_command_dump_list(s->exec_command[c], f, prefix2);
596 static int instance_from_socket(int fd, unsigned nr, char **instance) {
601 struct sockaddr_un un;
602 struct sockaddr_in in;
603 struct sockaddr_in6 in6;
604 struct sockaddr_storage storage;
611 if (getsockname(fd, &local.sa, &l) < 0)
615 if (getpeername(fd, &remote.sa, &l) < 0)
618 switch (local.sa.sa_family) {
622 a = ntohl(local.in.sin_addr.s_addr),
623 b = ntohl(remote.in.sin_addr.s_addr);
626 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
628 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
629 ntohs(local.in.sin_port),
630 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
631 ntohs(remote.in.sin_port)) < 0)
638 static const unsigned char ipv4_prefix[] = {
639 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
642 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
643 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
645 *a = local.in6.sin6_addr.s6_addr+12,
646 *b = remote.in6.sin6_addr.s6_addr+12;
649 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
651 a[0], a[1], a[2], a[3],
652 ntohs(local.in6.sin6_port),
653 b[0], b[1], b[2], b[3],
654 ntohs(remote.in6.sin6_port)) < 0)
657 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
662 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
663 ntohs(local.in6.sin6_port),
664 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
665 ntohs(remote.in6.sin6_port)) < 0)
676 k = getpeercred(fd, &ucred);
683 (unsigned long) ucred.pid,
684 (unsigned long) ucred.uid) < 0)
691 assert_not_reached("Unhandled socket type.");
698 static void socket_close_fds(Socket *s) {
703 LIST_FOREACH(port, p, s->ports) {
705 p->event_source = sd_event_source_unref(p->event_source);
710 close_nointr_nofail(p->fd);
712 /* One little note: we should never delete any sockets
713 * in the file system here! After all some other
714 * process we spawned might still have a reference of
715 * this fd and wants to continue to use it. Therefore
716 * we delete sockets in the file system before we
717 * create a new one, not after we stopped using
724 static void socket_apply_socket_options(Socket *s, int fd) {
729 int b = s->keep_alive;
730 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
731 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
736 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
737 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
742 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
743 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
748 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
749 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
752 if (s->priority >= 0)
753 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
754 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
756 if (s->receive_buffer > 0) {
757 int value = (int) s->receive_buffer;
759 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
761 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
762 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
763 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
766 if (s->send_buffer > 0) {
767 int value = (int) s->send_buffer;
768 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
769 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
770 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
774 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
775 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
778 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
779 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
781 if (s->ip_ttl >= 0) {
784 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
786 if (socket_ipv6_is_supported())
787 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
790 errno = EAFNOSUPPORT;
794 log_warning_unit(UNIT(s)->id,
795 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
798 if (s->tcp_congestion)
799 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
800 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
803 int b = s->reuse_port;
804 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)) < 0)
805 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
809 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
810 log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
813 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
814 log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
817 static void socket_apply_fifo_options(Socket *s, int fd) {
821 if (s->pipe_size > 0)
822 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
823 log_warning_unit(UNIT(s)->id,
827 if (smack_label_fd(fd, s->smack) < 0)
828 log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
831 static int fifo_address_create(
833 mode_t directory_mode,
844 mkdir_parents_label(path, directory_mode);
846 r = label_context_set(path, S_IFIFO);
850 /* Enforce the right access mode for the fifo */
851 old_mask = umask(~ socket_mode);
853 /* Include the original umask in our mask */
854 umask(~socket_mode | old_mask);
856 r = mkfifo(path, socket_mode);
859 if (r < 0 && errno != EEXIST) {
864 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
869 label_context_clear();
871 if (fstat(fd, &st) < 0) {
876 if (!S_ISFIFO(st.st_mode) ||
877 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
878 st.st_uid != getuid() ||
879 st.st_gid != getgid()) {
889 label_context_clear();
892 close_nointr_nofail(fd);
897 static int special_address_create(
907 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
912 if (fstat(fd, &st) < 0) {
917 /* Check whether this is a /proc, /sys or /dev file or char device */
918 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
928 close_nointr_nofail(fd);
933 static int mq_address_create(
943 struct mq_attr _attr, *attr = NULL;
948 if (maxmsg > 0 && msgsize > 0) {
950 _attr.mq_flags = O_NONBLOCK;
951 _attr.mq_maxmsg = maxmsg;
952 _attr.mq_msgsize = msgsize;
956 /* Enforce the right access mode for the mq */
957 old_mask = umask(~ mq_mode);
959 /* Include the original umask in our mask */
960 umask(~mq_mode | old_mask);
962 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
970 if (fstat(fd, &st) < 0) {
975 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
976 st.st_uid != getuid() ||
977 st.st_gid != getgid()) {
988 close_nointr_nofail(fd);
993 static int socket_open_fds(Socket *s) {
997 bool know_label = false;
1001 LIST_FOREACH(port, p, s->ports) {
1006 if (p->type == SOCKET_SOCKET) {
1010 if ((r = socket_instantiate_service(s)) < 0)
1013 if (UNIT_ISSET(s->service) &&
1014 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1015 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1026 r = socket_address_listen(
1028 SOCK_CLOEXEC|SOCK_NONBLOCK,
1041 socket_apply_socket_options(s, p->fd);
1043 } else if (p->type == SOCKET_SPECIAL) {
1045 r = special_address_create(
1051 } else if (p->type == SOCKET_FIFO) {
1053 r = fifo_address_create(
1061 socket_apply_fifo_options(s, p->fd);
1062 } else if (p->type == SOCKET_MQUEUE) {
1064 r = mq_address_create(
1073 assert_not_reached("Unknown port type");
1080 socket_close_fds(s);
1085 static void socket_unwatch_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_OFF);
1098 log_debug_unit(UNIT(s)->id, "Failed to disable event source.");
1103 static int socket_watch_fds(Socket *s) {
1109 LIST_FOREACH(port, p, s->ports) {
1113 if (p->event_source)
1114 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1116 r = sd_event_add_io(UNIT(s)->manager->event, p->fd, EPOLLIN, socket_dispatch_io, p, &p->event_source);
1119 log_warning_unit(UNIT(s)->id, "Failed to watch listening fds: %s", strerror(-r));
1127 socket_unwatch_fds(s);
1131 static void socket_set_state(Socket *s, SocketState state) {
1132 SocketState old_state;
1135 old_state = s->state;
1138 if (state != SOCKET_START_PRE &&
1139 state != SOCKET_START_POST &&
1140 state != SOCKET_STOP_PRE &&
1141 state != SOCKET_STOP_PRE_SIGTERM &&
1142 state != SOCKET_STOP_PRE_SIGKILL &&
1143 state != SOCKET_STOP_POST &&
1144 state != SOCKET_FINAL_SIGTERM &&
1145 state != SOCKET_FINAL_SIGKILL) {
1147 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1148 socket_unwatch_control_pid(s);
1149 s->control_command = NULL;
1150 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1153 if (state != SOCKET_LISTENING)
1154 socket_unwatch_fds(s);
1156 if (state != SOCKET_START_POST &&
1157 state != SOCKET_LISTENING &&
1158 state != SOCKET_RUNNING &&
1159 state != SOCKET_STOP_PRE &&
1160 state != SOCKET_STOP_PRE_SIGTERM &&
1161 state != SOCKET_STOP_PRE_SIGKILL)
1162 socket_close_fds(s);
1164 if (state != old_state)
1165 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s",
1166 UNIT(s)->id, socket_state_to_string(old_state), socket_state_to_string(state));
1168 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1171 static int socket_coldplug(Unit *u) {
1172 Socket *s = SOCKET(u);
1176 assert(s->state == SOCKET_DEAD);
1178 if (s->deserialized_state == s->state)
1181 if (s->deserialized_state == SOCKET_START_PRE ||
1182 s->deserialized_state == SOCKET_START_POST ||
1183 s->deserialized_state == SOCKET_STOP_PRE ||
1184 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1185 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1186 s->deserialized_state == SOCKET_STOP_POST ||
1187 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1188 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1190 if (s->control_pid <= 0)
1193 r = unit_watch_pid(UNIT(s), s->control_pid);
1197 r = socket_arm_timer(s);
1202 if (s->deserialized_state == SOCKET_START_POST ||
1203 s->deserialized_state == SOCKET_LISTENING ||
1204 s->deserialized_state == SOCKET_RUNNING ||
1205 s->deserialized_state == SOCKET_STOP_PRE ||
1206 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1207 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL) {
1208 r = socket_open_fds(s);
1213 if (s->deserialized_state == SOCKET_LISTENING) {
1214 r = socket_watch_fds(s);
1219 socket_set_state(s, s->deserialized_state);
1223 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1232 unit_realize_cgroup(UNIT(s));
1234 r = unit_setup_exec_runtime(UNIT(s));
1238 r = socket_arm_timer(s);
1242 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1250 UNIT(s)->manager->environment,
1254 UNIT(s)->manager->confirm_spawn,
1255 UNIT(s)->manager->cgroup_supported,
1256 UNIT(s)->cgroup_path,
1267 r = unit_watch_pid(UNIT(s), pid);
1269 /* FIXME: we need to do something here */
1277 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1282 static void socket_enter_dead(Socket *s, SocketResult f) {
1285 if (f != SOCKET_SUCCESS)
1288 exec_runtime_destroy(s->exec_runtime);
1289 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1291 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1294 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1296 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1300 if (f != SOCKET_SUCCESS)
1303 socket_unwatch_control_pid(s);
1305 s->control_command_id = SOCKET_EXEC_STOP_POST;
1307 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1308 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1311 socket_set_state(s, SOCKET_STOP_POST);
1313 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1318 log_warning_unit(UNIT(s)->id,
1319 "%s failed to run 'stop-post' task: %s",
1320 UNIT(s)->id, strerror(-r));
1321 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1324 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1329 if (f != SOCKET_SUCCESS)
1332 r = unit_kill_context(
1335 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1343 r = socket_arm_timer(s);
1347 socket_set_state(s, state);
1348 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1349 socket_enter_stop_post(s, SOCKET_SUCCESS);
1351 socket_enter_dead(s, SOCKET_SUCCESS);
1356 log_warning_unit(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1358 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1359 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1361 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1364 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1368 if (f != SOCKET_SUCCESS)
1371 socket_unwatch_control_pid(s);
1373 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1375 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1376 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1379 socket_set_state(s, SOCKET_STOP_PRE);
1381 socket_enter_stop_post(s, SOCKET_SUCCESS);
1386 log_warning_unit(UNIT(s)->id, "%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1387 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1390 static void socket_enter_listening(Socket *s) {
1394 r = socket_watch_fds(s);
1396 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1400 socket_set_state(s, SOCKET_LISTENING);
1404 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1407 static void socket_enter_start_post(Socket *s) {
1411 r = socket_open_fds(s);
1413 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1417 socket_unwatch_control_pid(s);
1419 s->control_command_id = SOCKET_EXEC_START_POST;
1421 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1422 r = socket_spawn(s, s->control_command, &s->control_pid);
1424 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1428 socket_set_state(s, SOCKET_START_POST);
1430 socket_enter_listening(s);
1435 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1438 static void socket_enter_start_pre(Socket *s) {
1442 socket_unwatch_control_pid(s);
1444 s->control_command_id = SOCKET_EXEC_START_PRE;
1446 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1447 r = socket_spawn(s, s->control_command, &s->control_pid);
1451 socket_set_state(s, SOCKET_START_PRE);
1453 socket_enter_start_post(s);
1458 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1459 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1462 static void socket_enter_running(Socket *s, int cfd) {
1463 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1468 /* We don't take connections anymore if we are supposed to
1469 * shut down anyway */
1470 if (unit_stop_pending(UNIT(s))) {
1472 log_debug_unit(UNIT(s)->id, "Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1475 close_nointr_nofail(cfd);
1477 /* Flush all sockets by closing and reopening them */
1478 socket_close_fds(s);
1480 r = socket_open_fds(s);
1482 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1483 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1487 r = socket_watch_fds(s);
1489 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1490 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1500 bool pending = false;
1502 /* If there's already a start pending don't bother to
1504 SET_FOREACH(other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1505 if (unit_active_or_pending(other)) {
1511 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1516 socket_set_state(s, SOCKET_RUNNING);
1518 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1521 if (s->n_connections >= s->max_connections) {
1522 log_warning_unit(UNIT(s)->id, "%s: Too many incoming connections (%u)", UNIT(s)->id, s->n_connections);
1523 close_nointr_nofail(cfd);
1527 r = socket_instantiate_service(s);
1531 r = instance_from_socket(cfd, s->n_accepted, &instance);
1536 /* ENOTCONN is legitimate if TCP RST was received.
1537 * This connection is over, but the socket unit lives on. */
1538 close_nointr_nofail(cfd);
1542 prefix = unit_name_to_prefix(UNIT(s)->id);
1548 name = unit_name_build(prefix, instance, ".service");
1554 r = unit_add_name(UNIT_DEREF(s->service), name);
1558 service = SERVICE(UNIT_DEREF(s->service));
1559 unit_ref_unset(&s->service);
1562 UNIT(service)->no_gc = false;
1564 unit_choose_id(UNIT(service), name);
1566 r = service_set_socket_fd(service, cfd, s);
1571 s->n_connections ++;
1573 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1577 /* Notify clients about changed counters */
1578 unit_add_to_dbus_queue(UNIT(s));
1584 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",
1585 UNIT(s)->id, cfd >= 0 ? "template" : "non-template",
1586 bus_error_message(&error, r));
1588 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1591 close_nointr_nofail(cfd);
1594 static void socket_run_next(Socket *s) {
1598 assert(s->control_command);
1599 assert(s->control_command->command_next);
1601 socket_unwatch_control_pid(s);
1603 s->control_command = s->control_command->command_next;
1605 r = socket_spawn(s, s->control_command, &s->control_pid);
1612 log_warning_unit(UNIT(s)->id, "%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1614 if (s->state == SOCKET_START_POST)
1615 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1616 else if (s->state == SOCKET_STOP_POST)
1617 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1619 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1622 static int socket_start(Unit *u) {
1623 Socket *s = SOCKET(u);
1627 /* We cannot fulfill this request right now, try again later
1629 if (s->state == SOCKET_STOP_PRE ||
1630 s->state == SOCKET_STOP_PRE_SIGKILL ||
1631 s->state == SOCKET_STOP_PRE_SIGTERM ||
1632 s->state == SOCKET_STOP_POST ||
1633 s->state == SOCKET_FINAL_SIGTERM ||
1634 s->state == SOCKET_FINAL_SIGKILL)
1637 if (s->state == SOCKET_START_PRE ||
1638 s->state == SOCKET_START_POST)
1641 /* Cannot run this without the service being around */
1642 if (UNIT_ISSET(s->service)) {
1645 service = SERVICE(UNIT_DEREF(s->service));
1647 if (UNIT(service)->load_state != UNIT_LOADED) {
1648 log_error_unit(u->id, "Socket service %s not loaded, refusing.", UNIT(service)->id);
1652 /* If the service is already active we cannot start the
1654 if (service->state != SERVICE_DEAD &&
1655 service->state != SERVICE_FAILED &&
1656 service->state != SERVICE_AUTO_RESTART) {
1657 log_error_unit(u->id, "Socket service %s already active, refusing.", UNIT(service)->id);
1661 #ifdef HAVE_SYSV_COMPAT
1662 if (service->is_sysv) {
1663 log_error_unit(u->id,
1664 "Using SysV services for socket activation is not supported. Refusing.");
1670 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1672 s->result = SOCKET_SUCCESS;
1673 socket_enter_start_pre(s);
1678 static int socket_stop(Unit *u) {
1679 Socket *s = SOCKET(u);
1684 if (s->state == SOCKET_STOP_PRE ||
1685 s->state == SOCKET_STOP_PRE_SIGTERM ||
1686 s->state == SOCKET_STOP_PRE_SIGKILL ||
1687 s->state == SOCKET_STOP_POST ||
1688 s->state == SOCKET_FINAL_SIGTERM ||
1689 s->state == SOCKET_FINAL_SIGKILL)
1692 /* If there's already something running we go directly into
1694 if (s->state == SOCKET_START_PRE ||
1695 s->state == SOCKET_START_POST) {
1696 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1700 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1702 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1706 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1707 Socket *s = SOCKET(u);
1715 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1716 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1717 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1719 if (s->control_pid > 0)
1720 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1722 if (s->control_command_id >= 0)
1723 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1725 LIST_FOREACH(port, p, s->ports) {
1731 copy = fdset_put_dup(fds, p->fd);
1735 if (p->type == SOCKET_SOCKET) {
1736 _cleanup_free_ char *t = NULL;
1738 r = socket_address_print(&p->address, &t);
1742 if (socket_address_family(&p->address) == AF_NETLINK)
1743 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1745 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1747 } else if (p->type == SOCKET_SPECIAL)
1748 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1749 else if (p->type == SOCKET_MQUEUE)
1750 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1752 assert(p->type == SOCKET_FIFO);
1753 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1760 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1761 Socket *s = SOCKET(u);
1767 if (streq(key, "state")) {
1770 state = socket_state_from_string(value);
1772 log_debug_unit(u->id, "Failed to parse state value %s", value);
1774 s->deserialized_state = state;
1775 } else if (streq(key, "result")) {
1778 f = socket_result_from_string(value);
1780 log_debug_unit(u->id, "Failed to parse result value %s", value);
1781 else if (f != SOCKET_SUCCESS)
1784 } else if (streq(key, "n-accepted")) {
1787 if (safe_atou(value, &k) < 0)
1788 log_debug_unit(u->id, "Failed to parse n-accepted value %s", value);
1791 } else if (streq(key, "control-pid")) {
1794 if (parse_pid(value, &pid) < 0)
1795 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1797 s->control_pid = pid;
1798 } else if (streq(key, "control-command")) {
1799 SocketExecCommand id;
1801 id = socket_exec_command_from_string(value);
1803 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1805 s->control_command_id = id;
1806 s->control_command = s->exec_command[id];
1808 } else if (streq(key, "fifo")) {
1812 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1813 log_debug_unit(u->id, "Failed to parse fifo value %s", value);
1816 LIST_FOREACH(port, p, s->ports)
1817 if (p->type == SOCKET_FIFO &&
1818 streq_ptr(p->path, value+skip))
1823 close_nointr_nofail(p->fd);
1824 p->fd = fdset_remove(fds, fd);
1828 } else if (streq(key, "special")) {
1832 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1833 log_debug_unit(u->id, "Failed to parse special value %s", value);
1836 LIST_FOREACH(port, p, s->ports)
1837 if (p->type == SOCKET_SPECIAL &&
1838 streq_ptr(p->path, value+skip))
1843 close_nointr_nofail(p->fd);
1844 p->fd = fdset_remove(fds, fd);
1848 } else if (streq(key, "mqueue")) {
1852 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1853 log_debug_unit(u->id, "Failed to parse mqueue value %s", value);
1856 LIST_FOREACH(port, p, s->ports)
1857 if (p->type == SOCKET_MQUEUE &&
1858 streq_ptr(p->path, value+skip))
1863 close_nointr_nofail(p->fd);
1864 p->fd = fdset_remove(fds, fd);
1868 } else if (streq(key, "socket")) {
1869 int fd, type, skip = 0;
1872 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1873 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1876 LIST_FOREACH(port, p, s->ports)
1877 if (socket_address_is(&p->address, value+skip, type))
1882 close_nointr_nofail(p->fd);
1883 p->fd = fdset_remove(fds, fd);
1887 } else if (streq(key, "netlink")) {
1891 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1892 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1895 LIST_FOREACH(port, p, s->ports)
1896 if (socket_address_is_netlink(&p->address, value+skip))
1901 close_nointr_nofail(p->fd);
1902 p->fd = fdset_remove(fds, fd);
1906 log_debug_unit(UNIT(s)->id, "Unknown serialization key '%s'", key);
1911 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1912 Socket *s = SOCKET(u);
1917 LIST_FOREACH(port, p, s->ports) {
1921 if (p->type != SOCKET_SOCKET)
1927 FDSET_FOREACH(fd, fds, i) {
1928 if (socket_address_matches_fd(&p->address, fd)) {
1929 p->fd = fdset_remove(fds, fd);
1930 s->deserialized_state = SOCKET_LISTENING;
1939 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1942 return state_translation_table[SOCKET(u)->state];
1945 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1948 return socket_state_to_string(SOCKET(u)->state);
1951 const char* socket_port_type_to_string(SocketPort *p) {
1959 switch (p->address.type) {
1967 case SOCK_SEQPACKET:
1968 return "SequentialPacket";
1971 if (socket_address_family(&p->address) == AF_NETLINK)
1978 case SOCKET_SPECIAL:
1982 return "MessageQueue";
1992 _pure_ static bool socket_check_gc(Unit *u) {
1993 Socket *s = SOCKET(u);
1997 return s->n_connections > 0;
2000 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2001 SocketPort *p = userdata;
2007 if (p->socket->state != SOCKET_LISTENING)
2010 log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
2012 if (revents != EPOLLIN) {
2014 if (revents & EPOLLHUP)
2015 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.",
2016 UNIT(p->socket)->id);
2018 log_error_unit(UNIT(p->socket)->id, "%s: Got unexpected poll event (0x%x) on socket.",
2019 UNIT(p->socket)->id, revents);
2024 if (p->socket->accept &&
2025 p->type == SOCKET_SOCKET &&
2026 socket_address_can_accept(&p->address)) {
2030 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2036 log_error_unit(UNIT(p->socket)->id,
2037 "Failed to accept socket: %m");
2044 socket_apply_socket_options(p->socket, cfd);
2047 socket_enter_running(p->socket, cfd);
2051 socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2055 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2056 Socket *s = SOCKET(u);
2062 if (pid != s->control_pid)
2067 if (is_clean_exit(code, status, NULL))
2069 else if (code == CLD_EXITED)
2070 f = SOCKET_FAILURE_EXIT_CODE;
2071 else if (code == CLD_KILLED)
2072 f = SOCKET_FAILURE_SIGNAL;
2073 else if (code == CLD_DUMPED)
2074 f = SOCKET_FAILURE_CORE_DUMP;
2076 assert_not_reached("Unknown code");
2078 if (s->control_command) {
2079 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2081 if (s->control_command->ignore)
2085 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2087 "%s control process exited, code=%s status=%i",
2088 u->id, sigchld_code_to_string(code), status);
2090 if (f != SOCKET_SUCCESS)
2093 if (s->control_command &&
2094 s->control_command->command_next &&
2095 f == SOCKET_SUCCESS) {
2097 log_debug_unit(u->id,
2098 "%s running next command for state %s",
2099 u->id, socket_state_to_string(s->state));
2102 s->control_command = NULL;
2103 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2105 /* No further commands for this step, so let's figure
2106 * out what to do next */
2108 log_debug_unit(u->id,
2109 "%s got final SIGCHLD for state %s",
2110 u->id, socket_state_to_string(s->state));
2114 case SOCKET_START_PRE:
2115 if (f == SOCKET_SUCCESS)
2116 socket_enter_start_post(s);
2118 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2121 case SOCKET_START_POST:
2122 if (f == SOCKET_SUCCESS)
2123 socket_enter_listening(s);
2125 socket_enter_stop_pre(s, f);
2128 case SOCKET_STOP_PRE:
2129 case SOCKET_STOP_PRE_SIGTERM:
2130 case SOCKET_STOP_PRE_SIGKILL:
2131 socket_enter_stop_post(s, f);
2134 case SOCKET_STOP_POST:
2135 case SOCKET_FINAL_SIGTERM:
2136 case SOCKET_FINAL_SIGKILL:
2137 socket_enter_dead(s, f);
2141 assert_not_reached("Uh, control process died at wrong time.");
2145 /* Notify clients about changed exit status */
2146 unit_add_to_dbus_queue(u);
2149 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2150 Socket *s = SOCKET(userdata);
2153 assert(s->timer_event_source == source);
2157 case SOCKET_START_PRE:
2158 log_warning_unit(UNIT(s)->id,
2159 "%s starting timed out. Terminating.", UNIT(s)->id);
2160 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2163 case SOCKET_START_POST:
2164 log_warning_unit(UNIT(s)->id,
2165 "%s starting timed out. Stopping.", UNIT(s)->id);
2166 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2169 case SOCKET_STOP_PRE:
2170 log_warning_unit(UNIT(s)->id,
2171 "%s stopping timed out. Terminating.", UNIT(s)->id);
2172 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2175 case SOCKET_STOP_PRE_SIGTERM:
2176 if (s->kill_context.send_sigkill) {
2177 log_warning_unit(UNIT(s)->id,
2178 "%s stopping timed out. Killing.", UNIT(s)->id);
2179 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2181 log_warning_unit(UNIT(s)->id,
2182 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2184 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2188 case SOCKET_STOP_PRE_SIGKILL:
2189 log_warning_unit(UNIT(s)->id,
2190 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2191 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2194 case SOCKET_STOP_POST:
2195 log_warning_unit(UNIT(s)->id,
2196 "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2197 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2200 case SOCKET_FINAL_SIGTERM:
2201 if (s->kill_context.send_sigkill) {
2202 log_warning_unit(UNIT(s)->id,
2203 "%s stopping timed out (2). Killing.", UNIT(s)->id);
2204 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2206 log_warning_unit(UNIT(s)->id,
2207 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2209 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2213 case SOCKET_FINAL_SIGKILL:
2214 log_warning_unit(UNIT(s)->id,
2215 "%s still around after SIGKILL (2). Entering failed mode.",
2217 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2221 assert_not_reached("Timeout at wrong time.");
2227 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2236 /* Called from the service code for requesting our fds */
2239 LIST_FOREACH(port, p, s->ports)
2249 if (!(rfds = new(int, rn_fds)))
2253 LIST_FOREACH(port, p, s->ports)
2257 assert(k == rn_fds);
2265 static void socket_reset_failed(Unit *u) {
2266 Socket *s = SOCKET(u);
2270 if (s->state == SOCKET_FAILED)
2271 socket_set_state(s, SOCKET_DEAD);
2273 s->result = SOCKET_SUCCESS;
2276 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2279 /* The service is dead. Dang!
2281 * This is strictly for one-instance-for-all-connections
2284 if (s->state == SOCKET_RUNNING) {
2285 log_debug_unit(UNIT(s)->id, "%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2286 if (failed_permanent)
2287 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2289 socket_enter_listening(s);
2293 void socket_connection_unref(Socket *s) {
2296 /* The service is dead. Yay!
2298 * This is strictly for one-instance-per-connection
2301 assert(s->n_connections > 0);
2304 log_debug_unit(UNIT(s)->id, "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2307 static void socket_trigger_notify(Unit *u, Unit *other) {
2308 Socket *s = SOCKET(u);
2314 /* Don't propagate state changes from the service if we are
2315 already down or accepting connections */
2316 if ((s->state != SOCKET_RUNNING &&
2317 s->state != SOCKET_LISTENING) ||
2321 if (other->load_state != UNIT_LOADED ||
2322 other->type != UNIT_SERVICE)
2325 se = SERVICE(other);
2327 if (se->state == SERVICE_FAILED)
2328 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2330 if (se->state == SERVICE_DEAD ||
2331 se->state == SERVICE_STOP ||
2332 se->state == SERVICE_STOP_SIGTERM ||
2333 se->state == SERVICE_STOP_SIGKILL ||
2334 se->state == SERVICE_STOP_POST ||
2335 se->state == SERVICE_FINAL_SIGTERM ||
2336 se->state == SERVICE_FINAL_SIGKILL ||
2337 se->state == SERVICE_AUTO_RESTART)
2338 socket_notify_service_dead(s, false);
2340 if (se->state == SERVICE_RUNNING)
2341 socket_set_state(s, SOCKET_RUNNING);
2344 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2345 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2348 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2349 [SOCKET_DEAD] = "dead",
2350 [SOCKET_START_PRE] = "start-pre",
2351 [SOCKET_START_POST] = "start-post",
2352 [SOCKET_LISTENING] = "listening",
2353 [SOCKET_RUNNING] = "running",
2354 [SOCKET_STOP_PRE] = "stop-pre",
2355 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2356 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2357 [SOCKET_STOP_POST] = "stop-post",
2358 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2359 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2360 [SOCKET_FAILED] = "failed"
2363 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2365 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2366 [SOCKET_EXEC_START_PRE] = "StartPre",
2367 [SOCKET_EXEC_START_POST] = "StartPost",
2368 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2369 [SOCKET_EXEC_STOP_POST] = "StopPost"
2372 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2374 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2375 [SOCKET_SUCCESS] = "success",
2376 [SOCKET_FAILURE_RESOURCES] = "resources",
2377 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2378 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2379 [SOCKET_FAILURE_SIGNAL] = "signal",
2380 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2381 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2384 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2386 const UnitVTable socket_vtable = {
2387 .object_size = sizeof(Socket),
2388 .exec_context_offset = offsetof(Socket, exec_context),
2389 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2390 .kill_context_offset = offsetof(Socket, kill_context),
2391 .exec_runtime_offset = offsetof(Socket, exec_runtime),
2397 .private_section = "Socket",
2399 .init = socket_init,
2400 .done = socket_done,
2401 .load = socket_load,
2403 .coldplug = socket_coldplug,
2405 .dump = socket_dump,
2407 .start = socket_start,
2408 .stop = socket_stop,
2410 .kill = socket_kill,
2412 .serialize = socket_serialize,
2413 .deserialize_item = socket_deserialize_item,
2414 .distribute_fds = socket_distribute_fds,
2416 .active_state = socket_active_state,
2417 .sub_state_to_string = socket_sub_state_to_string,
2419 .check_gc = socket_check_gc,
2421 .sigchld_event = socket_sigchld_event,
2423 .trigger_notify = socket_trigger_notify,
2425 .reset_failed = socket_reset_failed,
2427 .bus_interface = "org.freedesktop.systemd1.Socket",
2428 .bus_vtable = bus_socket_vtable,
2429 .bus_set_property = bus_socket_set_property,
2430 .bus_commit_properties = bus_socket_commit_properties,
2432 .status_message_formats = {
2433 /*.starting_stopping = {
2434 [0] = "Starting socket %s...",
2435 [1] = "Stopping socket %s...",
2437 .finished_start_job = {
2438 [JOB_DONE] = "Listening on %s.",
2439 [JOB_FAILED] = "Failed to listen on %s.",
2440 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2441 [JOB_TIMEOUT] = "Timed out starting %s.",
2443 .finished_stop_job = {
2444 [JOB_DONE] = "Closed %s.",
2445 [JOB_FAILED] = "Failed stopping %s.",
2446 [JOB_TIMEOUT] = "Timed out stopping %s.",