1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include <sys/types.h>
27 #include <sys/epoll.h>
29 #include <arpa/inet.h>
30 #include <netinet/tcp.h>
33 #include <attr/xattr.h>
38 #include "load-dropin.h"
39 #include "load-fragment.h"
42 #include "path-util.h"
43 #include "unit-name.h"
44 #include "unit-printf.h"
48 #include "exit-status.h"
50 #include "smack-util.h"
52 #include "bus-error.h"
53 #include "dbus-socket.h"
57 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
58 [SOCKET_DEAD] = UNIT_INACTIVE,
59 [SOCKET_START_PRE] = UNIT_ACTIVATING,
60 [SOCKET_START_POST] = UNIT_ACTIVATING,
61 [SOCKET_LISTENING] = UNIT_ACTIVE,
62 [SOCKET_RUNNING] = UNIT_ACTIVE,
63 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
64 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
65 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
66 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
67 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
68 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
69 [SOCKET_FAILED] = UNIT_FAILED
72 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
73 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
75 static void socket_init(Unit *u) {
76 Socket *s = SOCKET(u);
79 assert(u->load_state == UNIT_STUB);
81 s->backlog = SOMAXCONN;
82 s->timeout_usec = u->manager->default_timeout_start_usec;
83 s->directory_mode = 0755;
84 s->socket_mode = 0666;
86 s->max_connections = 64;
93 s->exec_context.std_output = u->manager->default_std_output;
94 s->exec_context.std_error = u->manager->default_std_error;
96 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
99 static void socket_unwatch_control_pid(Socket *s) {
102 if (s->control_pid <= 0)
105 unit_unwatch_pid(UNIT(s), s->control_pid);
109 void socket_free_ports(Socket *s) {
114 while ((p = s->ports)) {
115 LIST_REMOVE(port, s->ports, p);
117 sd_event_source_unref(p->event_source);
125 static void socket_done(Unit *u) {
126 Socket *s = SOCKET(u);
130 socket_free_ports(s);
132 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
133 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
134 s->control_command = NULL;
136 socket_unwatch_control_pid(s);
138 unit_ref_unset(&s->service);
140 free(s->tcp_congestion);
141 s->tcp_congestion = NULL;
143 free(s->bind_to_device);
144 s->bind_to_device = NULL;
147 free(s->smack_ip_in);
148 free(s->smack_ip_out);
150 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
153 static int socket_arm_timer(Socket *s) {
158 if (s->timeout_usec <= 0) {
159 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
163 if (s->timer_event_source) {
164 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec);
168 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
171 return sd_event_add_monotonic(UNIT(s)->manager->event, &s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec, 0, socket_dispatch_timer, s);
174 static int socket_instantiate_service(Socket *s) {
175 _cleanup_free_ char *prefix = NULL;
176 _cleanup_free_ char *name = NULL;
182 /* This fills in s->service if it isn't filled in yet. For
183 * Accept=yes sockets we create the next connection service
184 * here. For Accept=no this is mostly a NOP since the service
185 * is figured out at load time anyway. */
187 if (UNIT_DEREF(s->service))
192 prefix = unit_name_to_prefix(UNIT(s)->id);
196 if (asprintf(&name, "%s@%u.service", prefix, s->n_accepted) < 0)
199 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
203 #ifdef HAVE_SYSV_COMPAT
204 if (SERVICE(u)->is_sysv) {
205 log_error("Using SysV services for socket activation is not supported. Refusing.");
211 unit_ref_set(&s->service, u);
213 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
216 static bool have_non_accept_socket(Socket *s) {
224 LIST_FOREACH(port, p, s->ports) {
226 if (p->type != SOCKET_SOCKET)
229 if (!socket_address_can_accept(&p->address))
236 static int socket_add_mount_links(Socket *s) {
242 LIST_FOREACH(port, p, s->ports) {
243 const char *path = NULL;
245 if (p->type == SOCKET_SOCKET)
246 path = socket_address_get_path(&p->address);
247 else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL)
253 r = unit_require_mounts_for(UNIT(s), path);
261 static int socket_add_device_link(Socket *s) {
266 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
269 t = strappenda("/sys/subsystem/net/devices/", s->bind_to_device);
270 return unit_add_node_link(UNIT(s), t, false);
273 static int socket_add_default_dependencies(Socket *s) {
277 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
281 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
282 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
287 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
290 _pure_ static bool socket_has_exec(Socket *s) {
294 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
295 if (s->exec_command[i])
301 static int socket_add_extras(Socket *s) {
307 if (have_non_accept_socket(s)) {
309 if (!UNIT_DEREF(s->service)) {
312 r = unit_load_related_unit(u, ".service", &x);
316 unit_ref_set(&s->service, x);
319 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
324 r = socket_add_mount_links(s);
328 r = socket_add_device_link(s);
332 r = unit_patch_contexts(u);
336 if (socket_has_exec(s)) {
337 r = unit_add_exec_dependencies(u, &s->exec_context);
341 r = unit_add_default_slice(u, &s->cgroup_context);
346 if (u->default_dependencies) {
347 r = socket_add_default_dependencies(s);
355 static int socket_verify(Socket *s) {
358 if (UNIT(s)->load_state != UNIT_LOADED)
362 log_error_unit(UNIT(s)->id, "%s lacks Listen setting. Refusing.", UNIT(s)->id);
366 if (s->accept && have_non_accept_socket(s)) {
367 log_error_unit(UNIT(s)->id, "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
372 if (s->accept && s->max_connections <= 0) {
373 log_error_unit(UNIT(s)->id, "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
377 if (s->accept && UNIT_DEREF(s->service)) {
378 log_error_unit(UNIT(s)->id, "Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
382 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
383 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
390 static int socket_load(Unit *u) {
391 Socket *s = SOCKET(u);
395 assert(u->load_state == UNIT_STUB);
397 r = unit_load_fragment_and_dropin(u);
401 if (u->load_state == UNIT_LOADED) {
402 /* This is a new unit? Then let's add in some extras */
403 r = socket_add_extras(s);
408 return socket_verify(s);
411 _const_ static const char* listen_lookup(int family, int type) {
413 if (family == AF_NETLINK)
414 return "ListenNetlink";
416 if (type == SOCK_STREAM)
417 return "ListenStream";
418 else if (type == SOCK_DGRAM)
419 return "ListenDatagram";
420 else if (type == SOCK_SEQPACKET)
421 return "ListenSequentialPacket";
423 assert_not_reached("Unknown socket type");
427 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
429 Socket *s = SOCKET(u);
436 prefix2 = strappenda(prefix, "\t");
439 "%sSocket State: %s\n"
441 "%sBindIPv6Only: %s\n"
443 "%sSocketMode: %04o\n"
444 "%sDirectoryMode: %04o\n"
447 "%sTransparent: %s\n"
449 "%sPassCredentials: %s\n"
450 "%sPassSecurity: %s\n"
451 "%sTCPCongestion: %s\n",
452 prefix, socket_state_to_string(s->state),
453 prefix, socket_result_to_string(s->result),
454 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
456 prefix, s->socket_mode,
457 prefix, s->directory_mode,
458 prefix, yes_no(s->keep_alive),
459 prefix, yes_no(s->free_bind),
460 prefix, yes_no(s->transparent),
461 prefix, yes_no(s->broadcast),
462 prefix, yes_no(s->pass_cred),
463 prefix, yes_no(s->pass_sec),
464 prefix, strna(s->tcp_congestion));
466 if (s->control_pid > 0)
468 "%sControl PID: %lu\n",
469 prefix, (unsigned long) s->control_pid);
471 if (s->bind_to_device)
473 "%sBindToDevice: %s\n",
474 prefix, s->bind_to_device);
479 "%sNConnections: %u\n"
480 "%sMaxConnections: %u\n",
481 prefix, s->n_accepted,
482 prefix, s->n_connections,
483 prefix, s->max_connections);
485 if (s->priority >= 0)
488 prefix, s->priority);
490 if (s->receive_buffer > 0)
492 "%sReceiveBuffer: %zu\n",
493 prefix, s->receive_buffer);
495 if (s->send_buffer > 0)
497 "%sSendBuffer: %zu\n",
498 prefix, s->send_buffer);
510 if (s->pipe_size > 0)
513 prefix, s->pipe_size);
520 if (s->mq_maxmsg > 0)
522 "%sMessageQueueMaxMessages: %li\n",
523 prefix, s->mq_maxmsg);
525 if (s->mq_msgsize > 0)
527 "%sMessageQueueMessageSize: %li\n",
528 prefix, s->mq_msgsize);
533 prefix, yes_no(s->reuse_port));
537 "%sSmackLabel: %s\n",
542 "%sSmackLabelIPIn: %s\n",
543 prefix, s->smack_ip_in);
547 "%sSmackLabelIPOut: %s\n",
548 prefix, s->smack_ip_out);
550 LIST_FOREACH(port, p, s->ports) {
552 if (p->type == SOCKET_SOCKET) {
557 if ((r = socket_address_print(&p->address, &k)) < 0)
562 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
564 } else if (p->type == SOCKET_SPECIAL)
565 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
566 else if (p->type == SOCKET_MQUEUE)
567 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
569 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
572 exec_context_dump(&s->exec_context, f, prefix);
573 kill_context_dump(&s->kill_context, f, prefix);
575 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
576 if (!s->exec_command[c])
579 fprintf(f, "%s-> %s:\n",
580 prefix, socket_exec_command_to_string(c));
582 exec_command_dump_list(s->exec_command[c], f, prefix2);
586 static int instance_from_socket(int fd, unsigned nr, char **instance) {
589 union sockaddr_union local, remote;
595 if (getsockname(fd, &local.sa, &l) < 0)
599 if (getpeername(fd, &remote.sa, &l) < 0)
602 switch (local.sa.sa_family) {
606 a = ntohl(local.in.sin_addr.s_addr),
607 b = ntohl(remote.in.sin_addr.s_addr);
610 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
612 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
613 ntohs(local.in.sin_port),
614 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
615 ntohs(remote.in.sin_port)) < 0)
622 static const unsigned char ipv4_prefix[] = {
623 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
626 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
627 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
629 *a = local.in6.sin6_addr.s6_addr+12,
630 *b = remote.in6.sin6_addr.s6_addr+12;
633 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
635 a[0], a[1], a[2], a[3],
636 ntohs(local.in6.sin6_port),
637 b[0], b[1], b[2], b[3],
638 ntohs(remote.in6.sin6_port)) < 0)
641 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
646 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
647 ntohs(local.in6.sin6_port),
648 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
649 ntohs(remote.in6.sin6_port)) < 0)
660 k = getpeercred(fd, &ucred);
667 (unsigned long) ucred.pid,
668 (unsigned long) ucred.uid) < 0)
675 assert_not_reached("Unhandled socket type.");
682 static void socket_close_fds(Socket *s) {
687 LIST_FOREACH(port, p, s->ports) {
689 p->event_source = sd_event_source_unref(p->event_source);
694 p->fd = safe_close(p->fd);
696 /* One little note: we should never delete any sockets
697 * in the file system here! After all some other
698 * process we spawned might still have a reference of
699 * this fd and wants to continue to use it. Therefore
700 * we delete sockets in the file system before we
701 * create a new one, not after we stopped using
706 static void socket_apply_socket_options(Socket *s, int fd) {
711 int b = s->keep_alive;
712 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
713 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
718 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
719 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
724 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
725 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
730 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
731 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
734 if (s->priority >= 0)
735 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
736 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
738 if (s->receive_buffer > 0) {
739 int value = (int) s->receive_buffer;
741 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
743 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
744 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
745 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
748 if (s->send_buffer > 0) {
749 int value = (int) s->send_buffer;
750 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
751 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
752 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
756 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
757 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
760 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
761 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
763 if (s->ip_ttl >= 0) {
766 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
768 if (socket_ipv6_is_supported())
769 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
772 errno = EAFNOSUPPORT;
776 log_warning_unit(UNIT(s)->id,
777 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
780 if (s->tcp_congestion)
781 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
782 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
785 int b = s->reuse_port;
786 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)) < 0)
787 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
791 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
792 log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
795 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
796 log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
799 static void socket_apply_fifo_options(Socket *s, int fd) {
803 if (s->pipe_size > 0)
804 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
805 log_warning_unit(UNIT(s)->id,
809 if (smack_label_fd(fd, s->smack) < 0)
810 log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
813 static int fifo_address_create(
815 mode_t directory_mode,
826 mkdir_parents_label(path, directory_mode);
828 r = label_context_set(path, S_IFIFO);
832 /* Enforce the right access mode for the fifo */
833 old_mask = umask(~ socket_mode);
835 /* Include the original umask in our mask */
836 umask(~socket_mode | old_mask);
838 r = mkfifo(path, socket_mode);
841 if (r < 0 && errno != EEXIST) {
846 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
851 label_context_clear();
853 if (fstat(fd, &st) < 0) {
858 if (!S_ISFIFO(st.st_mode) ||
859 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
860 st.st_uid != getuid() ||
861 st.st_gid != getgid()) {
871 label_context_clear();
877 static int special_address_create(
887 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
892 if (fstat(fd, &st) < 0) {
897 /* Check whether this is a /proc, /sys or /dev file or char device */
898 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
912 static int mq_address_create(
922 struct mq_attr _attr, *attr = NULL;
927 if (maxmsg > 0 && msgsize > 0) {
929 _attr.mq_flags = O_NONBLOCK;
930 _attr.mq_maxmsg = maxmsg;
931 _attr.mq_msgsize = msgsize;
935 /* Enforce the right access mode for the mq */
936 old_mask = umask(~ mq_mode);
938 /* Include the original umask in our mask */
939 umask(~mq_mode | old_mask);
941 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
949 if (fstat(fd, &st) < 0) {
954 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
955 st.st_uid != getuid() ||
956 st.st_gid != getgid()) {
970 static int socket_open_fds(Socket *s) {
974 bool know_label = false;
978 LIST_FOREACH(port, p, s->ports) {
983 if (p->type == SOCKET_SOCKET) {
987 if ((r = socket_instantiate_service(s)) < 0)
990 if (UNIT_ISSET(s->service) &&
991 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
992 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1003 r = socket_address_listen(
1005 SOCK_CLOEXEC|SOCK_NONBLOCK,
1018 socket_apply_socket_options(s, p->fd);
1020 } else if (p->type == SOCKET_SPECIAL) {
1022 r = special_address_create(
1028 } else if (p->type == SOCKET_FIFO) {
1030 r = fifo_address_create(
1038 socket_apply_fifo_options(s, p->fd);
1039 } else if (p->type == SOCKET_MQUEUE) {
1041 r = mq_address_create(
1050 assert_not_reached("Unknown port type");
1057 socket_close_fds(s);
1062 static void socket_unwatch_fds(Socket *s) {
1068 LIST_FOREACH(port, p, s->ports) {
1072 if (p->event_source) {
1073 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_OFF);
1075 log_debug_unit(UNIT(s)->id, "Failed to disable event source.");
1080 static int socket_watch_fds(Socket *s) {
1086 LIST_FOREACH(port, p, s->ports) {
1090 if (p->event_source)
1091 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1093 r = sd_event_add_io(UNIT(s)->manager->event, &p->event_source, p->fd, EPOLLIN, socket_dispatch_io, p);
1096 log_warning_unit(UNIT(s)->id, "Failed to watch listening fds: %s", strerror(-r));
1104 socket_unwatch_fds(s);
1108 static void socket_set_state(Socket *s, SocketState state) {
1109 SocketState old_state;
1112 old_state = s->state;
1115 if (state != SOCKET_START_PRE &&
1116 state != SOCKET_START_POST &&
1117 state != SOCKET_STOP_PRE &&
1118 state != SOCKET_STOP_PRE_SIGTERM &&
1119 state != SOCKET_STOP_PRE_SIGKILL &&
1120 state != SOCKET_STOP_POST &&
1121 state != SOCKET_FINAL_SIGTERM &&
1122 state != SOCKET_FINAL_SIGKILL) {
1124 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1125 socket_unwatch_control_pid(s);
1126 s->control_command = NULL;
1127 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1130 if (state != SOCKET_LISTENING)
1131 socket_unwatch_fds(s);
1133 if (state != SOCKET_START_POST &&
1134 state != SOCKET_LISTENING &&
1135 state != SOCKET_RUNNING &&
1136 state != SOCKET_STOP_PRE &&
1137 state != SOCKET_STOP_PRE_SIGTERM &&
1138 state != SOCKET_STOP_PRE_SIGKILL)
1139 socket_close_fds(s);
1141 if (state != old_state)
1142 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s",
1143 UNIT(s)->id, socket_state_to_string(old_state), socket_state_to_string(state));
1145 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1148 static int socket_coldplug(Unit *u) {
1149 Socket *s = SOCKET(u);
1153 assert(s->state == SOCKET_DEAD);
1155 if (s->deserialized_state == s->state)
1158 if (s->deserialized_state == SOCKET_START_PRE ||
1159 s->deserialized_state == SOCKET_START_POST ||
1160 s->deserialized_state == SOCKET_STOP_PRE ||
1161 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1162 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1163 s->deserialized_state == SOCKET_STOP_POST ||
1164 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1165 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1167 if (s->control_pid <= 0)
1170 r = unit_watch_pid(UNIT(s), s->control_pid);
1174 r = socket_arm_timer(s);
1179 if (s->deserialized_state == SOCKET_START_POST ||
1180 s->deserialized_state == SOCKET_LISTENING ||
1181 s->deserialized_state == SOCKET_RUNNING ||
1182 s->deserialized_state == SOCKET_STOP_PRE ||
1183 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1184 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL) {
1185 r = socket_open_fds(s);
1190 if (s->deserialized_state == SOCKET_LISTENING) {
1191 r = socket_watch_fds(s);
1196 socket_set_state(s, s->deserialized_state);
1200 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1209 unit_realize_cgroup(UNIT(s));
1211 r = unit_setup_exec_runtime(UNIT(s));
1215 r = socket_arm_timer(s);
1219 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1227 UNIT(s)->manager->environment,
1231 UNIT(s)->manager->confirm_spawn,
1232 UNIT(s)->manager->cgroup_supported,
1233 UNIT(s)->cgroup_path,
1234 manager_get_runtime_prefix(UNIT(s)->manager),
1245 r = unit_watch_pid(UNIT(s), pid);
1247 /* FIXME: we need to do something here */
1255 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1260 static void socket_enter_dead(Socket *s, SocketResult f) {
1263 if (f != SOCKET_SUCCESS)
1266 exec_runtime_destroy(s->exec_runtime);
1267 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1269 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1271 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1274 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1276 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1280 if (f != SOCKET_SUCCESS)
1283 socket_unwatch_control_pid(s);
1285 s->control_command_id = SOCKET_EXEC_STOP_POST;
1287 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1288 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1291 socket_set_state(s, SOCKET_STOP_POST);
1293 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1298 log_warning_unit(UNIT(s)->id,
1299 "%s failed to run 'stop-post' task: %s",
1300 UNIT(s)->id, strerror(-r));
1301 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1304 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1309 if (f != SOCKET_SUCCESS)
1312 r = unit_kill_context(
1315 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1323 r = socket_arm_timer(s);
1327 socket_set_state(s, state);
1328 } else if (state == SOCKET_STOP_PRE_SIGTERM)
1329 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_SUCCESS);
1330 else if (state == SOCKET_STOP_PRE_SIGKILL)
1331 socket_enter_stop_post(s, SOCKET_SUCCESS);
1332 else if (state == SOCKET_FINAL_SIGTERM)
1333 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
1335 socket_enter_dead(s, SOCKET_SUCCESS);
1340 log_warning_unit(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1342 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1343 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1345 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1348 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1352 if (f != SOCKET_SUCCESS)
1355 socket_unwatch_control_pid(s);
1357 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1359 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1360 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1363 socket_set_state(s, SOCKET_STOP_PRE);
1365 socket_enter_stop_post(s, SOCKET_SUCCESS);
1370 log_warning_unit(UNIT(s)->id, "%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1371 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1374 static void socket_enter_listening(Socket *s) {
1378 r = socket_watch_fds(s);
1380 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1384 socket_set_state(s, SOCKET_LISTENING);
1388 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1391 static void socket_enter_start_post(Socket *s) {
1395 r = socket_open_fds(s);
1397 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1401 socket_unwatch_control_pid(s);
1403 s->control_command_id = SOCKET_EXEC_START_POST;
1405 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1406 r = socket_spawn(s, s->control_command, &s->control_pid);
1408 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1412 socket_set_state(s, SOCKET_START_POST);
1414 socket_enter_listening(s);
1419 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1422 static void socket_enter_start_pre(Socket *s) {
1426 socket_unwatch_control_pid(s);
1428 s->control_command_id = SOCKET_EXEC_START_PRE;
1430 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1431 r = socket_spawn(s, s->control_command, &s->control_pid);
1435 socket_set_state(s, SOCKET_START_PRE);
1437 socket_enter_start_post(s);
1442 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1443 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1446 static void socket_enter_running(Socket *s, int cfd) {
1447 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1452 /* We don't take connections anymore if we are supposed to
1453 * shut down anyway */
1454 if (unit_stop_pending(UNIT(s))) {
1456 log_debug_unit(UNIT(s)->id, "Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1461 /* Flush all sockets by closing and reopening them */
1462 socket_close_fds(s);
1464 r = socket_open_fds(s);
1466 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1467 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1471 r = socket_watch_fds(s);
1473 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1474 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1484 bool pending = false;
1486 /* If there's already a start pending don't bother to
1488 SET_FOREACH(other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1489 if (unit_active_or_pending(other)) {
1495 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1500 socket_set_state(s, SOCKET_RUNNING);
1502 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1505 if (s->n_connections >= s->max_connections) {
1506 log_warning_unit(UNIT(s)->id, "%s: Too many incoming connections (%u)", UNIT(s)->id, s->n_connections);
1511 r = socket_instantiate_service(s);
1515 r = instance_from_socket(cfd, s->n_accepted, &instance);
1520 /* ENOTCONN is legitimate if TCP RST was received.
1521 * This connection is over, but the socket unit lives on. */
1526 prefix = unit_name_to_prefix(UNIT(s)->id);
1532 name = unit_name_build(prefix, instance, ".service");
1538 r = unit_add_name(UNIT_DEREF(s->service), name);
1542 service = SERVICE(UNIT_DEREF(s->service));
1543 unit_ref_unset(&s->service);
1546 UNIT(service)->no_gc = false;
1548 unit_choose_id(UNIT(service), name);
1550 r = service_set_socket_fd(service, cfd, s);
1555 s->n_connections ++;
1557 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1561 /* Notify clients about changed counters */
1562 unit_add_to_dbus_queue(UNIT(s));
1568 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",
1569 UNIT(s)->id, cfd >= 0 ? "template" : "non-template",
1570 bus_error_message(&error, r));
1572 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1576 static void socket_run_next(Socket *s) {
1580 assert(s->control_command);
1581 assert(s->control_command->command_next);
1583 socket_unwatch_control_pid(s);
1585 s->control_command = s->control_command->command_next;
1587 r = socket_spawn(s, s->control_command, &s->control_pid);
1594 log_warning_unit(UNIT(s)->id, "%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1596 if (s->state == SOCKET_START_POST)
1597 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1598 else if (s->state == SOCKET_STOP_POST)
1599 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1601 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1604 static int socket_start(Unit *u) {
1605 Socket *s = SOCKET(u);
1609 /* We cannot fulfill this request right now, try again later
1611 if (s->state == SOCKET_STOP_PRE ||
1612 s->state == SOCKET_STOP_PRE_SIGKILL ||
1613 s->state == SOCKET_STOP_PRE_SIGTERM ||
1614 s->state == SOCKET_STOP_POST ||
1615 s->state == SOCKET_FINAL_SIGTERM ||
1616 s->state == SOCKET_FINAL_SIGKILL)
1619 if (s->state == SOCKET_START_PRE ||
1620 s->state == SOCKET_START_POST)
1623 /* Cannot run this without the service being around */
1624 if (UNIT_ISSET(s->service)) {
1627 service = SERVICE(UNIT_DEREF(s->service));
1629 if (UNIT(service)->load_state != UNIT_LOADED) {
1630 log_error_unit(u->id, "Socket service %s not loaded, refusing.", UNIT(service)->id);
1634 /* If the service is already active we cannot start the
1636 if (service->state != SERVICE_DEAD &&
1637 service->state != SERVICE_FAILED &&
1638 service->state != SERVICE_AUTO_RESTART) {
1639 log_error_unit(u->id, "Socket service %s already active, refusing.", UNIT(service)->id);
1643 #ifdef HAVE_SYSV_COMPAT
1644 if (service->is_sysv) {
1645 log_error_unit(u->id,
1646 "Using SysV services for socket activation is not supported. Refusing.");
1652 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1654 s->result = SOCKET_SUCCESS;
1655 socket_enter_start_pre(s);
1660 static int socket_stop(Unit *u) {
1661 Socket *s = SOCKET(u);
1666 if (s->state == SOCKET_STOP_PRE ||
1667 s->state == SOCKET_STOP_PRE_SIGTERM ||
1668 s->state == SOCKET_STOP_PRE_SIGKILL ||
1669 s->state == SOCKET_STOP_POST ||
1670 s->state == SOCKET_FINAL_SIGTERM ||
1671 s->state == SOCKET_FINAL_SIGKILL)
1674 /* If there's already something running we go directly into
1676 if (s->state == SOCKET_START_PRE ||
1677 s->state == SOCKET_START_POST) {
1678 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1682 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1684 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1688 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1689 Socket *s = SOCKET(u);
1697 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1698 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1699 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1701 if (s->control_pid > 0)
1702 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1704 if (s->control_command_id >= 0)
1705 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1707 LIST_FOREACH(port, p, s->ports) {
1713 copy = fdset_put_dup(fds, p->fd);
1717 if (p->type == SOCKET_SOCKET) {
1718 _cleanup_free_ char *t = NULL;
1720 r = socket_address_print(&p->address, &t);
1724 if (socket_address_family(&p->address) == AF_NETLINK)
1725 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1727 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1729 } else if (p->type == SOCKET_SPECIAL)
1730 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1731 else if (p->type == SOCKET_MQUEUE)
1732 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1734 assert(p->type == SOCKET_FIFO);
1735 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1742 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1743 Socket *s = SOCKET(u);
1749 if (streq(key, "state")) {
1752 state = socket_state_from_string(value);
1754 log_debug_unit(u->id, "Failed to parse state value %s", value);
1756 s->deserialized_state = state;
1757 } else if (streq(key, "result")) {
1760 f = socket_result_from_string(value);
1762 log_debug_unit(u->id, "Failed to parse result value %s", value);
1763 else if (f != SOCKET_SUCCESS)
1766 } else if (streq(key, "n-accepted")) {
1769 if (safe_atou(value, &k) < 0)
1770 log_debug_unit(u->id, "Failed to parse n-accepted value %s", value);
1773 } else if (streq(key, "control-pid")) {
1776 if (parse_pid(value, &pid) < 0)
1777 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1779 s->control_pid = pid;
1780 } else if (streq(key, "control-command")) {
1781 SocketExecCommand id;
1783 id = socket_exec_command_from_string(value);
1785 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1787 s->control_command_id = id;
1788 s->control_command = s->exec_command[id];
1790 } else if (streq(key, "fifo")) {
1794 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1795 log_debug_unit(u->id, "Failed to parse fifo value %s", value);
1798 LIST_FOREACH(port, p, s->ports)
1799 if (p->type == SOCKET_FIFO &&
1800 streq_ptr(p->path, value+skip))
1805 p->fd = fdset_remove(fds, fd);
1809 } else if (streq(key, "special")) {
1813 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1814 log_debug_unit(u->id, "Failed to parse special value %s", value);
1817 LIST_FOREACH(port, p, s->ports)
1818 if (p->type == SOCKET_SPECIAL &&
1819 streq_ptr(p->path, value+skip))
1824 p->fd = fdset_remove(fds, fd);
1828 } else if (streq(key, "mqueue")) {
1832 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1833 log_debug_unit(u->id, "Failed to parse mqueue value %s", value);
1836 LIST_FOREACH(port, p, s->ports)
1837 if (p->type == SOCKET_MQUEUE &&
1838 streq_ptr(p->path, value+skip))
1843 p->fd = fdset_remove(fds, fd);
1847 } else if (streq(key, "socket")) {
1848 int fd, type, skip = 0;
1851 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1852 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1855 LIST_FOREACH(port, p, s->ports)
1856 if (socket_address_is(&p->address, value+skip, type))
1861 p->fd = fdset_remove(fds, fd);
1865 } else if (streq(key, "netlink")) {
1869 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1870 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1873 LIST_FOREACH(port, p, s->ports)
1874 if (socket_address_is_netlink(&p->address, value+skip))
1879 p->fd = fdset_remove(fds, fd);
1883 log_debug_unit(UNIT(s)->id, "Unknown serialization key '%s'", key);
1888 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1889 Socket *s = SOCKET(u);
1894 LIST_FOREACH(port, p, s->ports) {
1898 if (p->type != SOCKET_SOCKET)
1904 FDSET_FOREACH(fd, fds, i) {
1905 if (socket_address_matches_fd(&p->address, fd)) {
1906 p->fd = fdset_remove(fds, fd);
1907 s->deserialized_state = SOCKET_LISTENING;
1916 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1919 return state_translation_table[SOCKET(u)->state];
1922 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1925 return socket_state_to_string(SOCKET(u)->state);
1928 const char* socket_port_type_to_string(SocketPort *p) {
1936 switch (p->address.type) {
1944 case SOCK_SEQPACKET:
1945 return "SequentialPacket";
1948 if (socket_address_family(&p->address) == AF_NETLINK)
1955 case SOCKET_SPECIAL:
1959 return "MessageQueue";
1969 _pure_ static bool socket_check_gc(Unit *u) {
1970 Socket *s = SOCKET(u);
1974 return s->n_connections > 0;
1977 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1978 SocketPort *p = userdata;
1984 if (p->socket->state != SOCKET_LISTENING)
1987 log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
1989 if (revents != EPOLLIN) {
1991 if (revents & EPOLLHUP)
1992 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.",
1993 UNIT(p->socket)->id);
1995 log_error_unit(UNIT(p->socket)->id, "%s: Got unexpected poll event (0x%x) on socket.",
1996 UNIT(p->socket)->id, revents);
2001 if (p->socket->accept &&
2002 p->type == SOCKET_SOCKET &&
2003 socket_address_can_accept(&p->address)) {
2007 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2013 log_error_unit(UNIT(p->socket)->id,
2014 "Failed to accept socket: %m");
2021 socket_apply_socket_options(p->socket, cfd);
2024 socket_enter_running(p->socket, cfd);
2028 socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2032 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2033 Socket *s = SOCKET(u);
2039 if (pid != s->control_pid)
2044 if (is_clean_exit(code, status, NULL))
2046 else if (code == CLD_EXITED)
2047 f = SOCKET_FAILURE_EXIT_CODE;
2048 else if (code == CLD_KILLED)
2049 f = SOCKET_FAILURE_SIGNAL;
2050 else if (code == CLD_DUMPED)
2051 f = SOCKET_FAILURE_CORE_DUMP;
2053 assert_not_reached("Unknown code");
2055 if (s->control_command) {
2056 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2058 if (s->control_command->ignore)
2062 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2064 "%s control process exited, code=%s status=%i",
2065 u->id, sigchld_code_to_string(code), status);
2067 if (f != SOCKET_SUCCESS)
2070 if (s->control_command &&
2071 s->control_command->command_next &&
2072 f == SOCKET_SUCCESS) {
2074 log_debug_unit(u->id,
2075 "%s running next command for state %s",
2076 u->id, socket_state_to_string(s->state));
2079 s->control_command = NULL;
2080 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2082 /* No further commands for this step, so let's figure
2083 * out what to do next */
2085 log_debug_unit(u->id,
2086 "%s got final SIGCHLD for state %s",
2087 u->id, socket_state_to_string(s->state));
2091 case SOCKET_START_PRE:
2092 if (f == SOCKET_SUCCESS)
2093 socket_enter_start_post(s);
2095 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2098 case SOCKET_START_POST:
2099 if (f == SOCKET_SUCCESS)
2100 socket_enter_listening(s);
2102 socket_enter_stop_pre(s, f);
2105 case SOCKET_STOP_PRE:
2106 case SOCKET_STOP_PRE_SIGTERM:
2107 case SOCKET_STOP_PRE_SIGKILL:
2108 socket_enter_stop_post(s, f);
2111 case SOCKET_STOP_POST:
2112 case SOCKET_FINAL_SIGTERM:
2113 case SOCKET_FINAL_SIGKILL:
2114 socket_enter_dead(s, f);
2118 assert_not_reached("Uh, control process died at wrong time.");
2122 /* Notify clients about changed exit status */
2123 unit_add_to_dbus_queue(u);
2126 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2127 Socket *s = SOCKET(userdata);
2130 assert(s->timer_event_source == source);
2134 case SOCKET_START_PRE:
2135 log_warning_unit(UNIT(s)->id,
2136 "%s starting timed out. Terminating.", UNIT(s)->id);
2137 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2140 case SOCKET_START_POST:
2141 log_warning_unit(UNIT(s)->id,
2142 "%s starting timed out. Stopping.", UNIT(s)->id);
2143 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2146 case SOCKET_STOP_PRE:
2147 log_warning_unit(UNIT(s)->id,
2148 "%s stopping timed out. Terminating.", UNIT(s)->id);
2149 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2152 case SOCKET_STOP_PRE_SIGTERM:
2153 if (s->kill_context.send_sigkill) {
2154 log_warning_unit(UNIT(s)->id,
2155 "%s stopping timed out. Killing.", UNIT(s)->id);
2156 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2158 log_warning_unit(UNIT(s)->id,
2159 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2161 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2165 case SOCKET_STOP_PRE_SIGKILL:
2166 log_warning_unit(UNIT(s)->id,
2167 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2168 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2171 case SOCKET_STOP_POST:
2172 log_warning_unit(UNIT(s)->id,
2173 "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2174 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2177 case SOCKET_FINAL_SIGTERM:
2178 if (s->kill_context.send_sigkill) {
2179 log_warning_unit(UNIT(s)->id,
2180 "%s stopping timed out (2). Killing.", UNIT(s)->id);
2181 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2183 log_warning_unit(UNIT(s)->id,
2184 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2186 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2190 case SOCKET_FINAL_SIGKILL:
2191 log_warning_unit(UNIT(s)->id,
2192 "%s still around after SIGKILL (2). Entering failed mode.",
2194 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2198 assert_not_reached("Timeout at wrong time.");
2204 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2213 /* Called from the service code for requesting our fds */
2216 LIST_FOREACH(port, p, s->ports)
2226 if (!(rfds = new(int, rn_fds)))
2230 LIST_FOREACH(port, p, s->ports)
2234 assert(k == rn_fds);
2242 static void socket_reset_failed(Unit *u) {
2243 Socket *s = SOCKET(u);
2247 if (s->state == SOCKET_FAILED)
2248 socket_set_state(s, SOCKET_DEAD);
2250 s->result = SOCKET_SUCCESS;
2253 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2256 /* The service is dead. Dang!
2258 * This is strictly for one-instance-for-all-connections
2261 if (s->state == SOCKET_RUNNING) {
2262 log_debug_unit(UNIT(s)->id, "%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2263 if (failed_permanent)
2264 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2266 socket_enter_listening(s);
2270 void socket_connection_unref(Socket *s) {
2273 /* The service is dead. Yay!
2275 * This is strictly for one-instance-per-connection
2278 assert(s->n_connections > 0);
2281 log_debug_unit(UNIT(s)->id, "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2284 static void socket_trigger_notify(Unit *u, Unit *other) {
2285 Socket *s = SOCKET(u);
2291 /* Don't propagate state changes from the service if we are
2292 already down or accepting connections */
2293 if ((s->state != SOCKET_RUNNING &&
2294 s->state != SOCKET_LISTENING) ||
2298 if (other->load_state != UNIT_LOADED ||
2299 other->type != UNIT_SERVICE)
2302 se = SERVICE(other);
2304 if (se->state == SERVICE_FAILED)
2305 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2307 if (se->state == SERVICE_DEAD ||
2308 se->state == SERVICE_STOP ||
2309 se->state == SERVICE_STOP_SIGTERM ||
2310 se->state == SERVICE_STOP_SIGKILL ||
2311 se->state == SERVICE_STOP_POST ||
2312 se->state == SERVICE_FINAL_SIGTERM ||
2313 se->state == SERVICE_FINAL_SIGKILL ||
2314 se->state == SERVICE_AUTO_RESTART)
2315 socket_notify_service_dead(s, false);
2317 if (se->state == SERVICE_RUNNING)
2318 socket_set_state(s, SOCKET_RUNNING);
2321 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2322 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2325 static int socket_get_timeout(Unit *u, uint64_t *timeout) {
2326 Socket *s = SOCKET(u);
2329 if (!s->timer_event_source)
2332 r = sd_event_source_get_time(s->timer_event_source, timeout);
2339 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2340 [SOCKET_DEAD] = "dead",
2341 [SOCKET_START_PRE] = "start-pre",
2342 [SOCKET_START_POST] = "start-post",
2343 [SOCKET_LISTENING] = "listening",
2344 [SOCKET_RUNNING] = "running",
2345 [SOCKET_STOP_PRE] = "stop-pre",
2346 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2347 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2348 [SOCKET_STOP_POST] = "stop-post",
2349 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2350 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2351 [SOCKET_FAILED] = "failed"
2354 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2356 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2357 [SOCKET_EXEC_START_PRE] = "StartPre",
2358 [SOCKET_EXEC_START_POST] = "StartPost",
2359 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2360 [SOCKET_EXEC_STOP_POST] = "StopPost"
2363 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2365 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2366 [SOCKET_SUCCESS] = "success",
2367 [SOCKET_FAILURE_RESOURCES] = "resources",
2368 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2369 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2370 [SOCKET_FAILURE_SIGNAL] = "signal",
2371 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2372 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2375 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2377 const UnitVTable socket_vtable = {
2378 .object_size = sizeof(Socket),
2379 .exec_context_offset = offsetof(Socket, exec_context),
2380 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2381 .kill_context_offset = offsetof(Socket, kill_context),
2382 .exec_runtime_offset = offsetof(Socket, exec_runtime),
2388 .private_section = "Socket",
2390 .init = socket_init,
2391 .done = socket_done,
2392 .load = socket_load,
2394 .coldplug = socket_coldplug,
2396 .dump = socket_dump,
2398 .start = socket_start,
2399 .stop = socket_stop,
2401 .kill = socket_kill,
2403 .get_timeout = socket_get_timeout,
2405 .serialize = socket_serialize,
2406 .deserialize_item = socket_deserialize_item,
2407 .distribute_fds = socket_distribute_fds,
2409 .active_state = socket_active_state,
2410 .sub_state_to_string = socket_sub_state_to_string,
2412 .check_gc = socket_check_gc,
2414 .sigchld_event = socket_sigchld_event,
2416 .trigger_notify = socket_trigger_notify,
2418 .reset_failed = socket_reset_failed,
2420 .bus_interface = "org.freedesktop.systemd1.Socket",
2421 .bus_vtable = bus_socket_vtable,
2422 .bus_set_property = bus_socket_set_property,
2423 .bus_commit_properties = bus_socket_commit_properties,
2425 .status_message_formats = {
2426 /*.starting_stopping = {
2427 [0] = "Starting socket %s...",
2428 [1] = "Stopping socket %s...",
2430 .finished_start_job = {
2431 [JOB_DONE] = "Listening on %s.",
2432 [JOB_FAILED] = "Failed to listen on %s.",
2433 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2434 [JOB_TIMEOUT] = "Timed out starting %s.",
2436 .finished_stop_job = {
2437 [JOB_DONE] = "Closed %s.",
2438 [JOB_FAILED] = "Failed stopping %s.",
2439 [JOB_TIMEOUT] = "Timed out stopping %s.",