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) {
182 _cleanup_free_ char *prefix = NULL;
183 _cleanup_free_ char *name = NULL;
189 /* This fills in s->service if it isn't filled in yet. For
190 * Accept=yes sockets we create the next connection service
191 * here. For Accept=no this is mostly a NOP since the service
192 * is figured out at load time anyway. */
194 if (UNIT_DEREF(s->service))
199 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
202 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
207 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
212 #ifdef HAVE_SYSV_COMPAT
213 if (SERVICE(u)->is_sysv) {
214 log_error("Using SysV services for socket activation is not supported. Refusing.");
220 unit_ref_set(&s->service, u);
222 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
225 static bool have_non_accept_socket(Socket *s) {
233 LIST_FOREACH(port, p, s->ports) {
235 if (p->type != SOCKET_SOCKET)
238 if (!socket_address_can_accept(&p->address))
245 static int socket_add_mount_links(Socket *s) {
251 LIST_FOREACH(port, p, s->ports) {
252 const char *path = NULL;
254 if (p->type == SOCKET_SOCKET)
255 path = socket_address_get_path(&p->address);
256 else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL)
262 r = unit_require_mounts_for(UNIT(s), path);
270 static int socket_add_device_link(Socket *s) {
275 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
278 t = strappenda("/sys/subsystem/net/devices/", s->bind_to_device);
279 return unit_add_node_link(UNIT(s), t, false);
282 static int socket_add_default_dependencies(Socket *s) {
286 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
290 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
291 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
296 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
299 _pure_ static bool socket_has_exec(Socket *s) {
303 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
304 if (s->exec_command[i])
310 static int socket_add_extras(Socket *s) {
316 if (have_non_accept_socket(s)) {
318 if (!UNIT_DEREF(s->service)) {
321 r = unit_load_related_unit(u, ".service", &x);
325 unit_ref_set(&s->service, x);
328 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
333 r = socket_add_mount_links(s);
337 r = socket_add_device_link(s);
341 r = unit_exec_context_defaults(u, &s->exec_context);
345 if (socket_has_exec(s)) {
346 r = unit_add_exec_dependencies(u, &s->exec_context);
350 r = unit_add_default_slice(u);
355 if (u->default_dependencies) {
356 r = socket_add_default_dependencies(s);
364 static int socket_verify(Socket *s) {
367 if (UNIT(s)->load_state != UNIT_LOADED)
371 log_error_unit(UNIT(s)->id, "%s lacks Listen setting. Refusing.", UNIT(s)->id);
375 if (s->accept && have_non_accept_socket(s)) {
376 log_error_unit(UNIT(s)->id, "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
381 if (s->accept && s->max_connections <= 0) {
382 log_error_unit(UNIT(s)->id, "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
386 if (s->accept && UNIT_DEREF(s->service)) {
387 log_error_unit(UNIT(s)->id, "Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
391 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
392 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
399 static int socket_load(Unit *u) {
400 Socket *s = SOCKET(u);
404 assert(u->load_state == UNIT_STUB);
406 r = unit_load_fragment_and_dropin(u);
410 if (u->load_state == UNIT_LOADED) {
411 /* This is a new unit? Then let's add in some extras */
412 r = socket_add_extras(s);
417 return socket_verify(s);
420 _const_ static const char* listen_lookup(int family, int type) {
422 if (family == AF_NETLINK)
423 return "ListenNetlink";
425 if (type == SOCK_STREAM)
426 return "ListenStream";
427 else if (type == SOCK_DGRAM)
428 return "ListenDatagram";
429 else if (type == SOCK_SEQPACKET)
430 return "ListenSequentialPacket";
432 assert_not_reached("Unknown socket type");
436 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
438 Socket *s = SOCKET(u);
445 prefix2 = strappenda(prefix, "\t");
448 "%sSocket State: %s\n"
450 "%sBindIPv6Only: %s\n"
452 "%sSocketMode: %04o\n"
453 "%sDirectoryMode: %04o\n"
456 "%sTransparent: %s\n"
458 "%sPassCredentials: %s\n"
459 "%sPassSecurity: %s\n"
460 "%sTCPCongestion: %s\n",
461 prefix, socket_state_to_string(s->state),
462 prefix, socket_result_to_string(s->result),
463 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
465 prefix, s->socket_mode,
466 prefix, s->directory_mode,
467 prefix, yes_no(s->keep_alive),
468 prefix, yes_no(s->free_bind),
469 prefix, yes_no(s->transparent),
470 prefix, yes_no(s->broadcast),
471 prefix, yes_no(s->pass_cred),
472 prefix, yes_no(s->pass_sec),
473 prefix, strna(s->tcp_congestion));
475 if (s->control_pid > 0)
477 "%sControl PID: %lu\n",
478 prefix, (unsigned long) s->control_pid);
480 if (s->bind_to_device)
482 "%sBindToDevice: %s\n",
483 prefix, s->bind_to_device);
488 "%sNConnections: %u\n"
489 "%sMaxConnections: %u\n",
490 prefix, s->n_accepted,
491 prefix, s->n_connections,
492 prefix, s->max_connections);
494 if (s->priority >= 0)
497 prefix, s->priority);
499 if (s->receive_buffer > 0)
501 "%sReceiveBuffer: %zu\n",
502 prefix, s->receive_buffer);
504 if (s->send_buffer > 0)
506 "%sSendBuffer: %zu\n",
507 prefix, s->send_buffer);
519 if (s->pipe_size > 0)
522 prefix, s->pipe_size);
529 if (s->mq_maxmsg > 0)
531 "%sMessageQueueMaxMessages: %li\n",
532 prefix, s->mq_maxmsg);
534 if (s->mq_msgsize > 0)
536 "%sMessageQueueMessageSize: %li\n",
537 prefix, s->mq_msgsize);
542 prefix, yes_no(s->reuse_port));
546 "%sSmackLabel: %s\n",
551 "%sSmackLabelIPIn: %s\n",
552 prefix, s->smack_ip_in);
556 "%sSmackLabelIPOut: %s\n",
557 prefix, s->smack_ip_out);
559 LIST_FOREACH(port, p, s->ports) {
561 if (p->type == SOCKET_SOCKET) {
566 if ((r = socket_address_print(&p->address, &k)) < 0)
571 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
573 } else if (p->type == SOCKET_SPECIAL)
574 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
575 else if (p->type == SOCKET_MQUEUE)
576 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
578 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
581 exec_context_dump(&s->exec_context, f, prefix);
582 kill_context_dump(&s->kill_context, f, prefix);
584 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
585 if (!s->exec_command[c])
588 fprintf(f, "%s-> %s:\n",
589 prefix, socket_exec_command_to_string(c));
591 exec_command_dump_list(s->exec_command[c], f, prefix2);
595 static int instance_from_socket(int fd, unsigned nr, char **instance) {
600 struct sockaddr_un un;
601 struct sockaddr_in in;
602 struct sockaddr_in6 in6;
603 struct sockaddr_storage storage;
610 if (getsockname(fd, &local.sa, &l) < 0)
614 if (getpeername(fd, &remote.sa, &l) < 0)
617 switch (local.sa.sa_family) {
621 a = ntohl(local.in.sin_addr.s_addr),
622 b = ntohl(remote.in.sin_addr.s_addr);
625 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
627 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
628 ntohs(local.in.sin_port),
629 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
630 ntohs(remote.in.sin_port)) < 0)
637 static const unsigned char ipv4_prefix[] = {
638 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
641 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
642 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
644 *a = local.in6.sin6_addr.s6_addr+12,
645 *b = remote.in6.sin6_addr.s6_addr+12;
648 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
650 a[0], a[1], a[2], a[3],
651 ntohs(local.in6.sin6_port),
652 b[0], b[1], b[2], b[3],
653 ntohs(remote.in6.sin6_port)) < 0)
656 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
661 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
662 ntohs(local.in6.sin6_port),
663 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
664 ntohs(remote.in6.sin6_port)) < 0)
675 k = getpeercred(fd, &ucred);
682 (unsigned long) ucred.pid,
683 (unsigned long) ucred.uid) < 0)
690 assert_not_reached("Unhandled socket type.");
697 static void socket_close_fds(Socket *s) {
702 LIST_FOREACH(port, p, s->ports) {
704 p->event_source = sd_event_source_unref(p->event_source);
709 close_nointr_nofail(p->fd);
711 /* One little note: we should never delete any sockets
712 * in the file system here! After all some other
713 * process we spawned might still have a reference of
714 * this fd and wants to continue to use it. Therefore
715 * we delete sockets in the file system before we
716 * create a new one, not after we stopped using
723 static void socket_apply_socket_options(Socket *s, int fd) {
728 int b = s->keep_alive;
729 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
730 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
735 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
736 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
741 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
742 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
747 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
748 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
751 if (s->priority >= 0)
752 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
753 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
755 if (s->receive_buffer > 0) {
756 int value = (int) s->receive_buffer;
758 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
760 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
761 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
762 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
765 if (s->send_buffer > 0) {
766 int value = (int) s->send_buffer;
767 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
768 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
769 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
773 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
774 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
777 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
778 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
780 if (s->ip_ttl >= 0) {
783 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
785 if (socket_ipv6_is_supported())
786 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
789 errno = EAFNOSUPPORT;
793 log_warning_unit(UNIT(s)->id,
794 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
797 if (s->tcp_congestion)
798 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
799 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
802 int b = s->reuse_port;
803 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)) < 0)
804 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
808 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
809 log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
812 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
813 log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
816 static void socket_apply_fifo_options(Socket *s, int fd) {
820 if (s->pipe_size > 0)
821 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
822 log_warning_unit(UNIT(s)->id,
826 if (smack_label_fd(fd, s->smack) < 0)
827 log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
830 static int fifo_address_create(
832 mode_t directory_mode,
843 mkdir_parents_label(path, directory_mode);
845 r = label_context_set(path, S_IFIFO);
849 /* Enforce the right access mode for the fifo */
850 old_mask = umask(~ socket_mode);
852 /* Include the original umask in our mask */
853 umask(~socket_mode | old_mask);
855 r = mkfifo(path, socket_mode);
858 if (r < 0 && errno != EEXIST) {
863 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
868 label_context_clear();
870 if (fstat(fd, &st) < 0) {
875 if (!S_ISFIFO(st.st_mode) ||
876 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
877 st.st_uid != getuid() ||
878 st.st_gid != getgid()) {
888 label_context_clear();
891 close_nointr_nofail(fd);
896 static int special_address_create(
906 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
911 if (fstat(fd, &st) < 0) {
916 /* Check whether this is a /proc, /sys or /dev file or char device */
917 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
927 close_nointr_nofail(fd);
932 static int mq_address_create(
942 struct mq_attr _attr, *attr = NULL;
947 if (maxmsg > 0 && msgsize > 0) {
949 _attr.mq_flags = O_NONBLOCK;
950 _attr.mq_maxmsg = maxmsg;
951 _attr.mq_msgsize = msgsize;
955 /* Enforce the right access mode for the mq */
956 old_mask = umask(~ mq_mode);
958 /* Include the original umask in our mask */
959 umask(~mq_mode | old_mask);
961 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
969 if (fstat(fd, &st) < 0) {
974 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
975 st.st_uid != getuid() ||
976 st.st_gid != getgid()) {
987 close_nointr_nofail(fd);
992 static int socket_open_fds(Socket *s) {
996 bool know_label = false;
1000 LIST_FOREACH(port, p, s->ports) {
1005 if (p->type == SOCKET_SOCKET) {
1009 if ((r = socket_instantiate_service(s)) < 0)
1012 if (UNIT_ISSET(s->service) &&
1013 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1014 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1025 r = socket_address_listen(
1027 SOCK_CLOEXEC|SOCK_NONBLOCK,
1040 socket_apply_socket_options(s, p->fd);
1042 } else if (p->type == SOCKET_SPECIAL) {
1044 r = special_address_create(
1050 } else if (p->type == SOCKET_FIFO) {
1052 r = fifo_address_create(
1060 socket_apply_fifo_options(s, p->fd);
1061 } else if (p->type == SOCKET_MQUEUE) {
1063 r = mq_address_create(
1072 assert_not_reached("Unknown port type");
1079 socket_close_fds(s);
1084 static void socket_unwatch_fds(Socket *s) {
1090 LIST_FOREACH(port, p, s->ports) {
1094 if (p->event_source) {
1095 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_OFF);
1097 log_debug_unit(UNIT(s)->id, "Failed to disable event source.");
1102 static int socket_watch_fds(Socket *s) {
1108 LIST_FOREACH(port, p, s->ports) {
1112 if (p->event_source)
1113 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1115 r = sd_event_add_io(UNIT(s)->manager->event, p->fd, EPOLLIN, socket_dispatch_io, p, &p->event_source);
1118 log_warning_unit(UNIT(s)->id, "Failed to watch listening fds: %s", strerror(-r));
1126 socket_unwatch_fds(s);
1130 static void socket_set_state(Socket *s, SocketState state) {
1131 SocketState old_state;
1134 old_state = s->state;
1137 if (state != SOCKET_START_PRE &&
1138 state != SOCKET_START_POST &&
1139 state != SOCKET_STOP_PRE &&
1140 state != SOCKET_STOP_PRE_SIGTERM &&
1141 state != SOCKET_STOP_PRE_SIGKILL &&
1142 state != SOCKET_STOP_POST &&
1143 state != SOCKET_FINAL_SIGTERM &&
1144 state != SOCKET_FINAL_SIGKILL) {
1146 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1147 socket_unwatch_control_pid(s);
1148 s->control_command = NULL;
1149 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1152 if (state != SOCKET_LISTENING)
1153 socket_unwatch_fds(s);
1155 if (state != SOCKET_START_POST &&
1156 state != SOCKET_LISTENING &&
1157 state != SOCKET_RUNNING &&
1158 state != SOCKET_STOP_PRE &&
1159 state != SOCKET_STOP_PRE_SIGTERM &&
1160 state != SOCKET_STOP_PRE_SIGKILL)
1161 socket_close_fds(s);
1163 if (state != old_state)
1164 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s",
1165 UNIT(s)->id, socket_state_to_string(old_state), socket_state_to_string(state));
1167 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1170 static int socket_coldplug(Unit *u) {
1171 Socket *s = SOCKET(u);
1175 assert(s->state == SOCKET_DEAD);
1177 if (s->deserialized_state == s->state)
1180 if (s->deserialized_state == SOCKET_START_PRE ||
1181 s->deserialized_state == SOCKET_START_POST ||
1182 s->deserialized_state == SOCKET_STOP_PRE ||
1183 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1184 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1185 s->deserialized_state == SOCKET_STOP_POST ||
1186 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1187 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1189 if (s->control_pid <= 0)
1192 r = unit_watch_pid(UNIT(s), s->control_pid);
1196 r = socket_arm_timer(s);
1201 if (s->deserialized_state == SOCKET_START_POST ||
1202 s->deserialized_state == SOCKET_LISTENING ||
1203 s->deserialized_state == SOCKET_RUNNING ||
1204 s->deserialized_state == SOCKET_STOP_PRE ||
1205 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1206 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL) {
1207 r = socket_open_fds(s);
1212 if (s->deserialized_state == SOCKET_LISTENING) {
1213 r = socket_watch_fds(s);
1218 socket_set_state(s, s->deserialized_state);
1222 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1231 unit_realize_cgroup(UNIT(s));
1233 r = unit_setup_exec_runtime(UNIT(s));
1237 r = socket_arm_timer(s);
1241 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1249 UNIT(s)->manager->environment,
1253 UNIT(s)->manager->confirm_spawn,
1254 UNIT(s)->manager->cgroup_supported,
1255 UNIT(s)->cgroup_path,
1266 r = unit_watch_pid(UNIT(s), pid);
1268 /* FIXME: we need to do something here */
1276 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1281 static void socket_enter_dead(Socket *s, SocketResult f) {
1284 if (f != SOCKET_SUCCESS)
1287 exec_runtime_destroy(s->exec_runtime);
1288 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1290 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1293 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1295 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1299 if (f != SOCKET_SUCCESS)
1302 socket_unwatch_control_pid(s);
1304 s->control_command_id = SOCKET_EXEC_STOP_POST;
1306 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1307 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1310 socket_set_state(s, SOCKET_STOP_POST);
1312 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1317 log_warning_unit(UNIT(s)->id,
1318 "%s failed to run 'stop-post' task: %s",
1319 UNIT(s)->id, strerror(-r));
1320 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1323 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1328 if (f != SOCKET_SUCCESS)
1331 r = unit_kill_context(
1334 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1342 r = socket_arm_timer(s);
1346 socket_set_state(s, state);
1347 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1348 socket_enter_stop_post(s, SOCKET_SUCCESS);
1350 socket_enter_dead(s, SOCKET_SUCCESS);
1355 log_warning_unit(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1357 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1358 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1360 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1363 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1367 if (f != SOCKET_SUCCESS)
1370 socket_unwatch_control_pid(s);
1372 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1374 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1375 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1378 socket_set_state(s, SOCKET_STOP_PRE);
1380 socket_enter_stop_post(s, SOCKET_SUCCESS);
1385 log_warning_unit(UNIT(s)->id, "%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1386 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1389 static void socket_enter_listening(Socket *s) {
1393 r = socket_watch_fds(s);
1395 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1399 socket_set_state(s, SOCKET_LISTENING);
1403 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1406 static void socket_enter_start_post(Socket *s) {
1410 r = socket_open_fds(s);
1412 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1416 socket_unwatch_control_pid(s);
1418 s->control_command_id = SOCKET_EXEC_START_POST;
1420 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1421 r = socket_spawn(s, s->control_command, &s->control_pid);
1423 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1427 socket_set_state(s, SOCKET_START_POST);
1429 socket_enter_listening(s);
1434 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1437 static void socket_enter_start_pre(Socket *s) {
1441 socket_unwatch_control_pid(s);
1443 s->control_command_id = SOCKET_EXEC_START_PRE;
1445 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1446 r = socket_spawn(s, s->control_command, &s->control_pid);
1450 socket_set_state(s, SOCKET_START_PRE);
1452 socket_enter_start_post(s);
1457 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1458 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1461 static void socket_enter_running(Socket *s, int cfd) {
1462 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1467 /* We don't take connections anymore if we are supposed to
1468 * shut down anyway */
1469 if (unit_stop_pending(UNIT(s))) {
1471 log_debug_unit(UNIT(s)->id, "Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1474 close_nointr_nofail(cfd);
1476 /* Flush all sockets by closing and reopening them */
1477 socket_close_fds(s);
1479 r = socket_open_fds(s);
1481 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1482 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1486 r = socket_watch_fds(s);
1488 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1489 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1499 bool pending = false;
1501 /* If there's already a start pending don't bother to
1503 SET_FOREACH(other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1504 if (unit_active_or_pending(other)) {
1510 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1515 socket_set_state(s, SOCKET_RUNNING);
1517 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1520 if (s->n_connections >= s->max_connections) {
1521 log_warning_unit(UNIT(s)->id, "%s: Too many incoming connections (%u)", UNIT(s)->id, s->n_connections);
1522 close_nointr_nofail(cfd);
1526 r = socket_instantiate_service(s);
1530 r = instance_from_socket(cfd, s->n_accepted, &instance);
1535 /* ENOTCONN is legitimate if TCP RST was received.
1536 * This connection is over, but the socket unit lives on. */
1537 close_nointr_nofail(cfd);
1541 prefix = unit_name_to_prefix(UNIT(s)->id);
1547 name = unit_name_build(prefix, instance, ".service");
1553 r = unit_add_name(UNIT_DEREF(s->service), name);
1557 service = SERVICE(UNIT_DEREF(s->service));
1558 unit_ref_unset(&s->service);
1561 UNIT(service)->no_gc = false;
1563 unit_choose_id(UNIT(service), name);
1565 r = service_set_socket_fd(service, cfd, s);
1570 s->n_connections ++;
1572 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1576 /* Notify clients about changed counters */
1577 unit_add_to_dbus_queue(UNIT(s));
1583 log_warning_unit(UNIT(s)->id, "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1584 UNIT(s)->id, cfd >= 0 ? "template" : "non-template",
1585 bus_error_message(&error, r));
1587 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1590 close_nointr_nofail(cfd);
1593 static void socket_run_next(Socket *s) {
1597 assert(s->control_command);
1598 assert(s->control_command->command_next);
1600 socket_unwatch_control_pid(s);
1602 s->control_command = s->control_command->command_next;
1604 r = socket_spawn(s, s->control_command, &s->control_pid);
1611 log_warning_unit(UNIT(s)->id, "%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1613 if (s->state == SOCKET_START_POST)
1614 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1615 else if (s->state == SOCKET_STOP_POST)
1616 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1618 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1621 static int socket_start(Unit *u) {
1622 Socket *s = SOCKET(u);
1626 /* We cannot fulfill this request right now, try again later
1628 if (s->state == SOCKET_STOP_PRE ||
1629 s->state == SOCKET_STOP_PRE_SIGKILL ||
1630 s->state == SOCKET_STOP_PRE_SIGTERM ||
1631 s->state == SOCKET_STOP_POST ||
1632 s->state == SOCKET_FINAL_SIGTERM ||
1633 s->state == SOCKET_FINAL_SIGKILL)
1636 if (s->state == SOCKET_START_PRE ||
1637 s->state == SOCKET_START_POST)
1640 /* Cannot run this without the service being around */
1641 if (UNIT_ISSET(s->service)) {
1644 service = SERVICE(UNIT_DEREF(s->service));
1646 if (UNIT(service)->load_state != UNIT_LOADED) {
1647 log_error_unit(u->id, "Socket service %s not loaded, refusing.", UNIT(service)->id);
1651 /* If the service is already active we cannot start the
1653 if (service->state != SERVICE_DEAD &&
1654 service->state != SERVICE_FAILED &&
1655 service->state != SERVICE_AUTO_RESTART) {
1656 log_error_unit(u->id, "Socket service %s already active, refusing.", UNIT(service)->id);
1660 #ifdef HAVE_SYSV_COMPAT
1661 if (service->is_sysv) {
1662 log_error_unit(u->id,
1663 "Using SysV services for socket activation is not supported. Refusing.");
1669 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1671 s->result = SOCKET_SUCCESS;
1672 socket_enter_start_pre(s);
1677 static int socket_stop(Unit *u) {
1678 Socket *s = SOCKET(u);
1683 if (s->state == SOCKET_STOP_PRE ||
1684 s->state == SOCKET_STOP_PRE_SIGTERM ||
1685 s->state == SOCKET_STOP_PRE_SIGKILL ||
1686 s->state == SOCKET_STOP_POST ||
1687 s->state == SOCKET_FINAL_SIGTERM ||
1688 s->state == SOCKET_FINAL_SIGKILL)
1691 /* If there's already something running we go directly into
1693 if (s->state == SOCKET_START_PRE ||
1694 s->state == SOCKET_START_POST) {
1695 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1699 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1701 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1705 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1706 Socket *s = SOCKET(u);
1714 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1715 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1716 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1718 if (s->control_pid > 0)
1719 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1721 if (s->control_command_id >= 0)
1722 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1724 LIST_FOREACH(port, p, s->ports) {
1730 copy = fdset_put_dup(fds, p->fd);
1734 if (p->type == SOCKET_SOCKET) {
1735 _cleanup_free_ char *t = NULL;
1737 r = socket_address_print(&p->address, &t);
1741 if (socket_address_family(&p->address) == AF_NETLINK)
1742 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1744 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1746 } else if (p->type == SOCKET_SPECIAL)
1747 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1748 else if (p->type == SOCKET_MQUEUE)
1749 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1751 assert(p->type == SOCKET_FIFO);
1752 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1759 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1760 Socket *s = SOCKET(u);
1766 if (streq(key, "state")) {
1769 state = socket_state_from_string(value);
1771 log_debug_unit(u->id, "Failed to parse state value %s", value);
1773 s->deserialized_state = state;
1774 } else if (streq(key, "result")) {
1777 f = socket_result_from_string(value);
1779 log_debug_unit(u->id, "Failed to parse result value %s", value);
1780 else if (f != SOCKET_SUCCESS)
1783 } else if (streq(key, "n-accepted")) {
1786 if (safe_atou(value, &k) < 0)
1787 log_debug_unit(u->id, "Failed to parse n-accepted value %s", value);
1790 } else if (streq(key, "control-pid")) {
1793 if (parse_pid(value, &pid) < 0)
1794 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1796 s->control_pid = pid;
1797 } else if (streq(key, "control-command")) {
1798 SocketExecCommand id;
1800 id = socket_exec_command_from_string(value);
1802 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1804 s->control_command_id = id;
1805 s->control_command = s->exec_command[id];
1807 } else if (streq(key, "fifo")) {
1811 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1812 log_debug_unit(u->id, "Failed to parse fifo value %s", value);
1815 LIST_FOREACH(port, p, s->ports)
1816 if (p->type == SOCKET_FIFO &&
1817 streq_ptr(p->path, value+skip))
1822 close_nointr_nofail(p->fd);
1823 p->fd = fdset_remove(fds, fd);
1827 } else if (streq(key, "special")) {
1831 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1832 log_debug_unit(u->id, "Failed to parse special value %s", value);
1835 LIST_FOREACH(port, p, s->ports)
1836 if (p->type == SOCKET_SPECIAL &&
1837 streq_ptr(p->path, value+skip))
1842 close_nointr_nofail(p->fd);
1843 p->fd = fdset_remove(fds, fd);
1847 } else if (streq(key, "mqueue")) {
1851 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1852 log_debug_unit(u->id, "Failed to parse mqueue value %s", value);
1855 LIST_FOREACH(port, p, s->ports)
1856 if (p->type == SOCKET_MQUEUE &&
1857 streq_ptr(p->path, value+skip))
1862 close_nointr_nofail(p->fd);
1863 p->fd = fdset_remove(fds, fd);
1867 } else if (streq(key, "socket")) {
1868 int fd, type, skip = 0;
1871 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1872 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1875 LIST_FOREACH(port, p, s->ports)
1876 if (socket_address_is(&p->address, value+skip, type))
1881 close_nointr_nofail(p->fd);
1882 p->fd = fdset_remove(fds, fd);
1886 } else if (streq(key, "netlink")) {
1890 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1891 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1894 LIST_FOREACH(port, p, s->ports)
1895 if (socket_address_is_netlink(&p->address, value+skip))
1900 close_nointr_nofail(p->fd);
1901 p->fd = fdset_remove(fds, fd);
1905 log_debug_unit(UNIT(s)->id, "Unknown serialization key '%s'", key);
1910 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1911 Socket *s = SOCKET(u);
1916 LIST_FOREACH(port, p, s->ports) {
1920 if (p->type != SOCKET_SOCKET)
1926 FDSET_FOREACH(fd, fds, i) {
1927 if (socket_address_matches_fd(&p->address, fd)) {
1928 p->fd = fdset_remove(fds, fd);
1929 s->deserialized_state = SOCKET_LISTENING;
1938 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1941 return state_translation_table[SOCKET(u)->state];
1944 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1947 return socket_state_to_string(SOCKET(u)->state);
1950 const char* socket_port_type_to_string(SocketPort *p) {
1958 switch (p->address.type) {
1966 case SOCK_SEQPACKET:
1967 return "SequentialPacket";
1970 if (socket_address_family(&p->address) == AF_NETLINK)
1977 case SOCKET_SPECIAL:
1981 return "MessageQueue";
1991 _pure_ static bool socket_check_gc(Unit *u) {
1992 Socket *s = SOCKET(u);
1996 return s->n_connections > 0;
1999 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2000 SocketPort *p = userdata;
2006 if (p->socket->state != SOCKET_LISTENING)
2009 log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
2011 if (revents != EPOLLIN) {
2013 if (revents & EPOLLHUP)
2014 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.",
2015 UNIT(p->socket)->id);
2017 log_error_unit(UNIT(p->socket)->id, "%s: Got unexpected poll event (0x%x) on socket.",
2018 UNIT(p->socket)->id, revents);
2023 if (p->socket->accept &&
2024 p->type == SOCKET_SOCKET &&
2025 socket_address_can_accept(&p->address)) {
2029 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2035 log_error_unit(UNIT(p->socket)->id,
2036 "Failed to accept socket: %m");
2043 socket_apply_socket_options(p->socket, cfd);
2046 socket_enter_running(p->socket, cfd);
2050 socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2054 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2055 Socket *s = SOCKET(u);
2061 if (pid != s->control_pid)
2066 if (is_clean_exit(code, status, NULL))
2068 else if (code == CLD_EXITED)
2069 f = SOCKET_FAILURE_EXIT_CODE;
2070 else if (code == CLD_KILLED)
2071 f = SOCKET_FAILURE_SIGNAL;
2072 else if (code == CLD_DUMPED)
2073 f = SOCKET_FAILURE_CORE_DUMP;
2075 assert_not_reached("Unknown code");
2077 if (s->control_command) {
2078 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2080 if (s->control_command->ignore)
2084 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2086 "%s control process exited, code=%s status=%i",
2087 u->id, sigchld_code_to_string(code), status);
2089 if (f != SOCKET_SUCCESS)
2092 if (s->control_command &&
2093 s->control_command->command_next &&
2094 f == SOCKET_SUCCESS) {
2096 log_debug_unit(u->id,
2097 "%s running next command for state %s",
2098 u->id, socket_state_to_string(s->state));
2101 s->control_command = NULL;
2102 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2104 /* No further commands for this step, so let's figure
2105 * out what to do next */
2107 log_debug_unit(u->id,
2108 "%s got final SIGCHLD for state %s",
2109 u->id, socket_state_to_string(s->state));
2113 case SOCKET_START_PRE:
2114 if (f == SOCKET_SUCCESS)
2115 socket_enter_start_post(s);
2117 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2120 case SOCKET_START_POST:
2121 if (f == SOCKET_SUCCESS)
2122 socket_enter_listening(s);
2124 socket_enter_stop_pre(s, f);
2127 case SOCKET_STOP_PRE:
2128 case SOCKET_STOP_PRE_SIGTERM:
2129 case SOCKET_STOP_PRE_SIGKILL:
2130 socket_enter_stop_post(s, f);
2133 case SOCKET_STOP_POST:
2134 case SOCKET_FINAL_SIGTERM:
2135 case SOCKET_FINAL_SIGKILL:
2136 socket_enter_dead(s, f);
2140 assert_not_reached("Uh, control process died at wrong time.");
2144 /* Notify clients about changed exit status */
2145 unit_add_to_dbus_queue(u);
2148 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2149 Socket *s = SOCKET(userdata);
2152 assert(s->timer_event_source == source);
2156 case SOCKET_START_PRE:
2157 log_warning_unit(UNIT(s)->id,
2158 "%s starting timed out. Terminating.", UNIT(s)->id);
2159 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2162 case SOCKET_START_POST:
2163 log_warning_unit(UNIT(s)->id,
2164 "%s starting timed out. Stopping.", UNIT(s)->id);
2165 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2168 case SOCKET_STOP_PRE:
2169 log_warning_unit(UNIT(s)->id,
2170 "%s stopping timed out. Terminating.", UNIT(s)->id);
2171 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2174 case SOCKET_STOP_PRE_SIGTERM:
2175 if (s->kill_context.send_sigkill) {
2176 log_warning_unit(UNIT(s)->id,
2177 "%s stopping timed out. Killing.", UNIT(s)->id);
2178 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2180 log_warning_unit(UNIT(s)->id,
2181 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2183 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2187 case SOCKET_STOP_PRE_SIGKILL:
2188 log_warning_unit(UNIT(s)->id,
2189 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2190 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2193 case SOCKET_STOP_POST:
2194 log_warning_unit(UNIT(s)->id,
2195 "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2196 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2199 case SOCKET_FINAL_SIGTERM:
2200 if (s->kill_context.send_sigkill) {
2201 log_warning_unit(UNIT(s)->id,
2202 "%s stopping timed out (2). Killing.", UNIT(s)->id);
2203 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2205 log_warning_unit(UNIT(s)->id,
2206 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2208 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2212 case SOCKET_FINAL_SIGKILL:
2213 log_warning_unit(UNIT(s)->id,
2214 "%s still around after SIGKILL (2). Entering failed mode.",
2216 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2220 assert_not_reached("Timeout at wrong time.");
2226 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2235 /* Called from the service code for requesting our fds */
2238 LIST_FOREACH(port, p, s->ports)
2248 if (!(rfds = new(int, rn_fds)))
2252 LIST_FOREACH(port, p, s->ports)
2256 assert(k == rn_fds);
2264 static void socket_reset_failed(Unit *u) {
2265 Socket *s = SOCKET(u);
2269 if (s->state == SOCKET_FAILED)
2270 socket_set_state(s, SOCKET_DEAD);
2272 s->result = SOCKET_SUCCESS;
2275 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2278 /* The service is dead. Dang!
2280 * This is strictly for one-instance-for-all-connections
2283 if (s->state == SOCKET_RUNNING) {
2284 log_debug_unit(UNIT(s)->id, "%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2285 if (failed_permanent)
2286 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2288 socket_enter_listening(s);
2292 void socket_connection_unref(Socket *s) {
2295 /* The service is dead. Yay!
2297 * This is strictly for one-instance-per-connection
2300 assert(s->n_connections > 0);
2303 log_debug_unit(UNIT(s)->id, "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2306 static void socket_trigger_notify(Unit *u, Unit *other) {
2307 Socket *s = SOCKET(u);
2313 /* Don't propagate state changes from the service if we are
2314 already down or accepting connections */
2315 if ((s->state != SOCKET_RUNNING &&
2316 s->state != SOCKET_LISTENING) ||
2320 if (other->load_state != UNIT_LOADED ||
2321 other->type != UNIT_SERVICE)
2324 se = SERVICE(other);
2326 if (se->state == SERVICE_FAILED)
2327 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2329 if (se->state == SERVICE_DEAD ||
2330 se->state == SERVICE_STOP ||
2331 se->state == SERVICE_STOP_SIGTERM ||
2332 se->state == SERVICE_STOP_SIGKILL ||
2333 se->state == SERVICE_STOP_POST ||
2334 se->state == SERVICE_FINAL_SIGTERM ||
2335 se->state == SERVICE_FINAL_SIGKILL ||
2336 se->state == SERVICE_AUTO_RESTART)
2337 socket_notify_service_dead(s, false);
2339 if (se->state == SERVICE_RUNNING)
2340 socket_set_state(s, SOCKET_RUNNING);
2343 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2344 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2347 static int socket_get_timeout(Unit *u, uint64_t *timeout) {
2348 Socket *s = SOCKET(u);
2351 if (!s->timer_event_source)
2354 r = sd_event_source_get_time(s->timer_event_source, timeout);
2361 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2362 [SOCKET_DEAD] = "dead",
2363 [SOCKET_START_PRE] = "start-pre",
2364 [SOCKET_START_POST] = "start-post",
2365 [SOCKET_LISTENING] = "listening",
2366 [SOCKET_RUNNING] = "running",
2367 [SOCKET_STOP_PRE] = "stop-pre",
2368 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2369 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2370 [SOCKET_STOP_POST] = "stop-post",
2371 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2372 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2373 [SOCKET_FAILED] = "failed"
2376 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2378 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2379 [SOCKET_EXEC_START_PRE] = "StartPre",
2380 [SOCKET_EXEC_START_POST] = "StartPost",
2381 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2382 [SOCKET_EXEC_STOP_POST] = "StopPost"
2385 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2387 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2388 [SOCKET_SUCCESS] = "success",
2389 [SOCKET_FAILURE_RESOURCES] = "resources",
2390 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2391 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2392 [SOCKET_FAILURE_SIGNAL] = "signal",
2393 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2394 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2397 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2399 const UnitVTable socket_vtable = {
2400 .object_size = sizeof(Socket),
2401 .exec_context_offset = offsetof(Socket, exec_context),
2402 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2403 .kill_context_offset = offsetof(Socket, kill_context),
2404 .exec_runtime_offset = offsetof(Socket, exec_runtime),
2410 .private_section = "Socket",
2412 .init = socket_init,
2413 .done = socket_done,
2414 .load = socket_load,
2416 .coldplug = socket_coldplug,
2418 .dump = socket_dump,
2420 .start = socket_start,
2421 .stop = socket_stop,
2423 .kill = socket_kill,
2425 .get_timeout = socket_get_timeout,
2427 .serialize = socket_serialize,
2428 .deserialize_item = socket_deserialize_item,
2429 .distribute_fds = socket_distribute_fds,
2431 .active_state = socket_active_state,
2432 .sub_state_to_string = socket_sub_state_to_string,
2434 .check_gc = socket_check_gc,
2436 .sigchld_event = socket_sigchld_event,
2438 .trigger_notify = socket_trigger_notify,
2440 .reset_failed = socket_reset_failed,
2442 .bus_interface = "org.freedesktop.systemd1.Socket",
2443 .bus_vtable = bus_socket_vtable,
2444 .bus_set_property = bus_socket_set_property,
2445 .bus_commit_properties = bus_socket_commit_properties,
2447 .status_message_formats = {
2448 /*.starting_stopping = {
2449 [0] = "Starting socket %s...",
2450 [1] = "Stopping socket %s...",
2452 .finished_start_job = {
2453 [JOB_DONE] = "Listening on %s.",
2454 [JOB_FAILED] = "Failed to listen on %s.",
2455 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2456 [JOB_TIMEOUT] = "Timed out starting %s.",
2458 .finished_stop_job = {
2459 [JOB_DONE] = "Closed %s.",
2460 [JOB_FAILED] = "Failed stopping %s.",
2461 [JOB_TIMEOUT] = "Timed out stopping %s.",