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>
32 #include <attr/xattr.h>
37 #include "netinet/tcp.h"
39 #include "load-dropin.h"
40 #include "load-fragment.h"
43 #include "path-util.h"
44 #include "unit-name.h"
45 #include "unit-printf.h"
46 #include "dbus-socket.h"
49 #include "dbus-common.h"
51 #include "exit-status.h"
54 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
55 [SOCKET_DEAD] = UNIT_INACTIVE,
56 [SOCKET_START_PRE] = UNIT_ACTIVATING,
57 [SOCKET_START_POST] = UNIT_ACTIVATING,
58 [SOCKET_LISTENING] = UNIT_ACTIVE,
59 [SOCKET_RUNNING] = UNIT_ACTIVE,
60 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
61 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
62 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
63 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
64 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
65 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
66 [SOCKET_FAILED] = UNIT_FAILED
69 static void socket_init(Unit *u) {
70 Socket *s = SOCKET(u);
73 assert(u->load_state == UNIT_STUB);
75 s->backlog = SOMAXCONN;
76 s->timeout_usec = DEFAULT_TIMEOUT_USEC;
77 s->directory_mode = 0755;
78 s->socket_mode = 0666;
80 s->max_connections = 64;
87 exec_context_init(&s->exec_context);
88 s->exec_context.std_output = u->manager->default_std_output;
89 s->exec_context.std_error = u->manager->default_std_error;
90 kill_context_init(&s->kill_context);
92 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
95 static void socket_unwatch_control_pid(Socket *s) {
98 if (s->control_pid <= 0)
101 unit_unwatch_pid(UNIT(s), s->control_pid);
105 void socket_free_ports(Socket *s) {
110 while ((p = s->ports)) {
111 LIST_REMOVE(SocketPort, port, s->ports, p);
114 unit_unwatch_fd(UNIT(s), &p->fd_watch);
115 close_nointr_nofail(p->fd);
123 static void socket_done(Unit *u) {
124 Socket *s = SOCKET(u);
128 socket_free_ports(s);
130 exec_context_done(&s->exec_context, manager_is_reloading_or_reexecuting(u->manager));
131 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
132 s->control_command = NULL;
134 socket_unwatch_control_pid(s);
136 unit_ref_unset(&s->service);
138 free(s->tcp_congestion);
139 s->tcp_congestion = NULL;
141 free(s->bind_to_device);
142 s->bind_to_device = NULL;
145 free(s->smack_ip_in);
146 free(s->smack_ip_out);
148 unit_unwatch_timer(u, &s->timer_watch);
151 static int socket_instantiate_service(Socket *s) {
158 /* This fills in s->service if it isn't filled in yet. For
159 * Accept=yes sockets we create the next connection service
160 * here. For Accept=no this is mostly a NOP since the service
161 * is figured out at load time anyway. */
163 if (UNIT_DEREF(s->service))
168 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
171 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
177 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
183 #ifdef HAVE_SYSV_COMPAT
184 if (SERVICE(u)->is_sysv) {
185 log_error("Using SysV services for socket activation is not supported. Refusing.");
191 unit_ref_set(&s->service, u);
193 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
196 static bool have_non_accept_socket(Socket *s) {
204 LIST_FOREACH(port, p, s->ports) {
206 if (p->type != SOCKET_SOCKET)
209 if (!socket_address_can_accept(&p->address))
216 static int socket_verify(Socket *s) {
219 if (UNIT(s)->load_state != UNIT_LOADED)
223 log_error_unit(UNIT(s)->id,
224 "%s lacks Listen setting. Refusing.", UNIT(s)->id);
228 if (s->accept && have_non_accept_socket(s)) {
229 log_error_unit(UNIT(s)->id,
230 "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
235 if (s->accept && s->max_connections <= 0) {
236 log_error_unit(UNIT(s)->id,
237 "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
241 if (s->accept && UNIT_DEREF(s->service)) {
242 log_error_unit(UNIT(s)->id,
243 "Explicit service configuration for accepting sockets not supported on %s. Refusing.",
248 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
249 log_error_unit(UNIT(s)->id,
250 "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.",
258 static bool socket_needs_mount(Socket *s, const char *prefix) {
263 LIST_FOREACH(port, p, s->ports) {
265 if (p->type == SOCKET_SOCKET) {
266 if (socket_address_needs_mount(&p->address, prefix))
268 } else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL) {
269 if (path_startswith(p->path, prefix))
277 int socket_add_one_mount_link(Socket *s, Mount *m) {
283 if (UNIT(s)->load_state != UNIT_LOADED ||
284 UNIT(m)->load_state != UNIT_LOADED)
287 if (!socket_needs_mount(s, m->where))
290 r = unit_add_two_dependencies(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
297 static int socket_add_mount_links(Socket *s) {
303 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_MOUNT]) {
304 r = socket_add_one_mount_link(s, MOUNT(other));
312 static int socket_add_device_link(Socket *s) {
318 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
321 if (asprintf(&t, "/sys/subsystem/net/devices/%s", s->bind_to_device) < 0)
324 r = unit_add_node_link(UNIT(s), t, false);
330 static int socket_add_default_dependencies(Socket *s) {
334 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
338 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
339 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
344 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
347 _pure_ static bool socket_has_exec(Socket *s) {
351 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
352 if (s->exec_command[i])
358 static int socket_load(Unit *u) {
359 Socket *s = SOCKET(u);
363 assert(u->load_state == UNIT_STUB);
365 if ((r = unit_load_fragment_and_dropin(u)) < 0)
368 /* This is a new unit? Then let's add in some extras */
369 if (u->load_state == UNIT_LOADED) {
371 if (have_non_accept_socket(s)) {
373 if (!UNIT_DEREF(s->service)) {
376 r = unit_load_related_unit(u, ".service", &x);
380 unit_ref_set(&s->service, x);
383 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
388 if ((r = socket_add_mount_links(s)) < 0)
391 if ((r = socket_add_device_link(s)) < 0)
394 if (socket_has_exec(s))
395 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
398 r = unit_add_default_slice(u);
402 r = unit_add_default_cgroups(u);
406 if (UNIT(s)->default_dependencies)
407 if ((r = socket_add_default_dependencies(s)) < 0)
410 r = unit_exec_context_defaults(u, &s->exec_context);
415 return socket_verify(s);
418 _const_ static const char* listen_lookup(int family, int type) {
420 if (family == AF_NETLINK)
421 return "ListenNetlink";
423 if (type == SOCK_STREAM)
424 return "ListenStream";
425 else if (type == SOCK_DGRAM)
426 return "ListenDatagram";
427 else if (type == SOCK_SEQPACKET)
428 return "ListenSequentialPacket";
430 assert_not_reached("Unknown socket type");
434 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
437 Socket *s = SOCKET(u);
445 p2 = strappend(prefix, "\t");
446 prefix2 = p2 ? p2 : prefix;
449 "%sSocket State: %s\n"
451 "%sBindIPv6Only: %s\n"
453 "%sSocketMode: %04o\n"
454 "%sDirectoryMode: %04o\n"
457 "%sTransparent: %s\n"
459 "%sPassCredentials: %s\n"
460 "%sPassSecurity: %s\n"
461 "%sTCPCongestion: %s\n",
462 prefix, socket_state_to_string(s->state),
463 prefix, socket_result_to_string(s->result),
464 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
466 prefix, s->socket_mode,
467 prefix, s->directory_mode,
468 prefix, yes_no(s->keep_alive),
469 prefix, yes_no(s->free_bind),
470 prefix, yes_no(s->transparent),
471 prefix, yes_no(s->broadcast),
472 prefix, yes_no(s->pass_cred),
473 prefix, yes_no(s->pass_sec),
474 prefix, strna(s->tcp_congestion));
476 if (s->control_pid > 0)
478 "%sControl PID: %lu\n",
479 prefix, (unsigned long) s->control_pid);
481 if (s->bind_to_device)
483 "%sBindToDevice: %s\n",
484 prefix, s->bind_to_device);
489 "%sNConnections: %u\n"
490 "%sMaxConnections: %u\n",
491 prefix, s->n_accepted,
492 prefix, s->n_connections,
493 prefix, s->max_connections);
495 if (s->priority >= 0)
498 prefix, s->priority);
500 if (s->receive_buffer > 0)
502 "%sReceiveBuffer: %zu\n",
503 prefix, s->receive_buffer);
505 if (s->send_buffer > 0)
507 "%sSendBuffer: %zu\n",
508 prefix, s->send_buffer);
520 if (s->pipe_size > 0)
523 prefix, s->pipe_size);
530 if (s->mq_maxmsg > 0)
532 "%sMessageQueueMaxMessages: %li\n",
533 prefix, s->mq_maxmsg);
535 if (s->mq_msgsize > 0)
537 "%sMessageQueueMessageSize: %li\n",
538 prefix, s->mq_msgsize);
542 "%sSmackLabel: %s\n",
547 "%sSmackLabelIPIn: %s\n",
548 prefix, s->smack_ip_in);
552 "%sSmackLabelIPOut: %s\n",
553 prefix, s->smack_ip_out);
555 LIST_FOREACH(port, p, s->ports) {
557 if (p->type == SOCKET_SOCKET) {
562 if ((r = socket_address_print(&p->address, &k)) < 0)
567 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
569 } else if (p->type == SOCKET_SPECIAL)
570 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
571 else if (p->type == SOCKET_MQUEUE)
572 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
574 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
577 exec_context_dump(&s->exec_context, f, prefix);
578 kill_context_dump(&s->kill_context, f, prefix);
580 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
581 if (!s->exec_command[c])
584 fprintf(f, "%s-> %s:\n",
585 prefix, socket_exec_command_to_string(c));
587 exec_command_dump_list(s->exec_command[c], f, prefix2);
593 static int instance_from_socket(int fd, unsigned nr, char **instance) {
598 struct sockaddr_un un;
599 struct sockaddr_in in;
600 struct sockaddr_in6 in6;
601 struct sockaddr_storage storage;
608 if (getsockname(fd, &local.sa, &l) < 0)
612 if (getpeername(fd, &remote.sa, &l) < 0)
615 switch (local.sa.sa_family) {
619 a = ntohl(local.in.sin_addr.s_addr),
620 b = ntohl(remote.in.sin_addr.s_addr);
623 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
625 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
626 ntohs(local.in.sin_port),
627 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
628 ntohs(remote.in.sin_port)) < 0)
635 static const unsigned char ipv4_prefix[] = {
636 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
639 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
640 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
642 *a = local.in6.sin6_addr.s6_addr+12,
643 *b = remote.in6.sin6_addr.s6_addr+12;
646 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
648 a[0], a[1], a[2], a[3],
649 ntohs(local.in6.sin6_port),
650 b[0], b[1], b[2], b[3],
651 ntohs(remote.in6.sin6_port)) < 0)
654 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
659 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
660 ntohs(local.in6.sin6_port),
661 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
662 ntohs(remote.in6.sin6_port)) < 0)
673 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
679 (unsigned long) ucred.pid,
680 (unsigned long) ucred.uid) < 0)
687 assert_not_reached("Unhandled socket type.");
694 static void socket_close_fds(Socket *s) {
699 LIST_FOREACH(port, p, s->ports) {
703 unit_unwatch_fd(UNIT(s), &p->fd_watch);
704 close_nointr_nofail(p->fd);
706 /* One little note: we should never delete any sockets
707 * in the file system here! After all some other
708 * process we spawned might still have a reference of
709 * this fd and wants to continue to use it. Therefore
710 * we delete sockets in the file system before we
711 * create a new one, not after we stopped using
718 static void socket_apply_socket_options(Socket *s, int fd) {
723 int b = s->keep_alive;
724 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
725 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
730 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
731 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
736 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
737 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
742 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
743 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
746 if (s->priority >= 0)
747 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
748 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
750 if (s->receive_buffer > 0) {
751 int value = (int) s->receive_buffer;
753 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
755 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
756 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
757 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
760 if (s->send_buffer > 0) {
761 int value = (int) s->send_buffer;
762 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
763 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
764 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
768 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
769 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
772 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
773 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
775 if (s->ip_ttl >= 0) {
778 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
780 if (socket_ipv6_is_supported())
781 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
784 errno = EAFNOSUPPORT;
788 log_warning_unit(UNIT(s)->id,
789 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
792 if (s->tcp_congestion)
793 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
794 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
798 if (fsetxattr(fd, "security.SMACK64IPIN", s->smack_ip_in, strlen(s->smack_ip_in), 0) < 0)
799 log_error_unit(UNIT(s)->id,
800 "fsetxattr(\"security.SMACK64IPIN\"): %m");
803 if (fsetxattr(fd, "security.SMACK64IPOUT", s->smack_ip_out, strlen(s->smack_ip_out), 0) < 0)
804 log_error_unit(UNIT(s)->id,
805 "fsetxattr(\"security.SMACK64IPOUT\"): %m");
809 static void socket_apply_fifo_options(Socket *s, int fd) {
813 if (s->pipe_size > 0)
814 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
815 log_warning_unit(UNIT(s)->id,
820 if (fsetxattr(fd, "security.SMACK64", s->smack, strlen(s->smack), 0) < 0)
821 log_error_unit(UNIT(s)->id,
822 "fsetxattr(\"security.SMACK64\"): %m");
826 static int fifo_address_create(
828 mode_t directory_mode,
839 mkdir_parents_label(path, directory_mode);
841 r = label_context_set(path, S_IFIFO);
845 /* Enforce the right access mode for the fifo */
846 old_mask = umask(~ socket_mode);
848 /* Include the original umask in our mask */
849 umask(~socket_mode | old_mask);
851 r = mkfifo(path, socket_mode);
854 if (r < 0 && errno != EEXIST) {
859 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
864 label_context_clear();
866 if (fstat(fd, &st) < 0) {
871 if (!S_ISFIFO(st.st_mode) ||
872 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
873 st.st_uid != getuid() ||
874 st.st_gid != getgid()) {
884 label_context_clear();
887 close_nointr_nofail(fd);
892 static int special_address_create(
902 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
907 if (fstat(fd, &st) < 0) {
912 /* Check whether this is a /proc, /sys or /dev file or char device */
913 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
923 close_nointr_nofail(fd);
928 static int mq_address_create(
938 struct mq_attr _attr, *attr = NULL;
943 if (maxmsg > 0 && msgsize > 0) {
945 _attr.mq_flags = O_NONBLOCK;
946 _attr.mq_maxmsg = maxmsg;
947 _attr.mq_msgsize = msgsize;
951 /* Enforce the right access mode for the mq */
952 old_mask = umask(~ mq_mode);
954 /* Include the original umask in our mask */
955 umask(~mq_mode | old_mask);
957 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
965 if (fstat(fd, &st) < 0) {
970 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
971 st.st_uid != getuid() ||
972 st.st_gid != getgid()) {
983 close_nointr_nofail(fd);
988 static int socket_open_fds(Socket *s) {
992 bool know_label = false;
996 LIST_FOREACH(port, p, s->ports) {
1001 if (p->type == SOCKET_SOCKET) {
1005 if ((r = socket_instantiate_service(s)) < 0)
1008 if (UNIT_ISSET(s->service) &&
1009 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1010 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1021 if ((r = socket_address_listen(
1034 socket_apply_socket_options(s, p->fd);
1036 } else if (p->type == SOCKET_SPECIAL) {
1038 if ((r = special_address_create(
1043 } else if (p->type == SOCKET_FIFO) {
1045 if ((r = fifo_address_create(
1052 socket_apply_fifo_options(s, p->fd);
1053 } else if (p->type == SOCKET_MQUEUE) {
1055 if ((r = mq_address_create(
1063 assert_not_reached("Unknown port type");
1070 socket_close_fds(s);
1075 static void socket_unwatch_fds(Socket *s) {
1080 LIST_FOREACH(port, p, s->ports) {
1084 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1088 static int socket_watch_fds(Socket *s) {
1094 LIST_FOREACH(port, p, s->ports) {
1098 p->fd_watch.socket_accept =
1100 p->type == SOCKET_SOCKET &&
1101 socket_address_can_accept(&p->address);
1103 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1110 socket_unwatch_fds(s);
1114 static void socket_set_state(Socket *s, SocketState state) {
1115 SocketState old_state;
1118 old_state = s->state;
1121 if (state != SOCKET_START_PRE &&
1122 state != SOCKET_START_POST &&
1123 state != SOCKET_STOP_PRE &&
1124 state != SOCKET_STOP_PRE_SIGTERM &&
1125 state != SOCKET_STOP_PRE_SIGKILL &&
1126 state != SOCKET_STOP_POST &&
1127 state != SOCKET_FINAL_SIGTERM &&
1128 state != SOCKET_FINAL_SIGKILL) {
1129 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1130 socket_unwatch_control_pid(s);
1131 s->control_command = NULL;
1132 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1135 if (state != SOCKET_LISTENING)
1136 socket_unwatch_fds(s);
1138 if (state != SOCKET_START_POST &&
1139 state != SOCKET_LISTENING &&
1140 state != SOCKET_RUNNING &&
1141 state != SOCKET_STOP_PRE &&
1142 state != SOCKET_STOP_PRE_SIGTERM &&
1143 state != SOCKET_STOP_PRE_SIGKILL)
1144 socket_close_fds(s);
1146 if (state != old_state)
1147 log_debug_unit(UNIT(s)->id,
1148 "%s changed %s -> %s", UNIT(s)->id,
1149 socket_state_to_string(old_state),
1150 socket_state_to_string(state));
1152 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1155 static int socket_coldplug(Unit *u) {
1156 Socket *s = SOCKET(u);
1160 assert(s->state == SOCKET_DEAD);
1162 if (s->deserialized_state != s->state) {
1164 if (s->deserialized_state == SOCKET_START_PRE ||
1165 s->deserialized_state == SOCKET_START_POST ||
1166 s->deserialized_state == SOCKET_STOP_PRE ||
1167 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1168 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1169 s->deserialized_state == SOCKET_STOP_POST ||
1170 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1171 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1173 if (s->control_pid <= 0)
1176 r = unit_watch_pid(UNIT(s), s->control_pid);
1180 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1185 if (s->deserialized_state == SOCKET_START_POST ||
1186 s->deserialized_state == SOCKET_LISTENING ||
1187 s->deserialized_state == SOCKET_RUNNING ||
1188 s->deserialized_state == SOCKET_STOP_PRE ||
1189 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1190 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1191 if ((r = socket_open_fds(s)) < 0)
1194 if (s->deserialized_state == SOCKET_LISTENING)
1195 if ((r = socket_watch_fds(s)) < 0)
1198 socket_set_state(s, s->deserialized_state);
1204 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1213 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1217 argv = unit_full_printf_strv(UNIT(s), c->argv);
1227 UNIT(s)->manager->environment,
1231 UNIT(s)->manager->confirm_spawn,
1232 UNIT(s)->cgroup_bondings,
1233 UNIT(s)->cgroup_attributes,
1243 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1244 /* FIXME: we need to do something here */
1252 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1257 static void socket_enter_dead(Socket *s, SocketResult f) {
1260 if (f != SOCKET_SUCCESS)
1263 exec_context_tmp_dirs_done(&s->exec_context);
1264 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1267 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1269 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1273 if (f != SOCKET_SUCCESS)
1276 socket_unwatch_control_pid(s);
1278 s->control_command_id = SOCKET_EXEC_STOP_POST;
1280 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1281 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1284 socket_set_state(s, SOCKET_STOP_POST);
1286 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1291 log_warning_unit(UNIT(s)->id,
1292 "%s failed to run 'stop-post' task: %s",
1293 UNIT(s)->id, strerror(-r));
1294 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1297 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1302 if (f != SOCKET_SUCCESS)
1305 r = unit_kill_context(
1308 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1316 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1320 socket_set_state(s, state);
1321 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1322 socket_enter_stop_post(s, SOCKET_SUCCESS);
1324 socket_enter_dead(s, SOCKET_SUCCESS);
1329 log_warning_unit(UNIT(s)->id,
1330 "%s failed to kill processes: %s",
1331 UNIT(s)->id, strerror(-r));
1333 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1334 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1336 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1339 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1343 if (f != SOCKET_SUCCESS)
1346 socket_unwatch_control_pid(s);
1348 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1350 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1351 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1354 socket_set_state(s, SOCKET_STOP_PRE);
1356 socket_enter_stop_post(s, SOCKET_SUCCESS);
1361 log_warning_unit(UNIT(s)->id,
1362 "%s failed to run 'stop-pre' task: %s",
1363 UNIT(s)->id, strerror(-r));
1364 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1367 static void socket_enter_listening(Socket *s) {
1371 r = socket_watch_fds(s);
1373 log_warning_unit(UNIT(s)->id,
1374 "%s failed to watch sockets: %s",
1375 UNIT(s)->id, strerror(-r));
1379 socket_set_state(s, SOCKET_LISTENING);
1383 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1386 static void socket_enter_start_post(Socket *s) {
1390 r = socket_open_fds(s);
1392 log_warning_unit(UNIT(s)->id,
1393 "%s failed to listen on sockets: %s",
1394 UNIT(s)->id, strerror(-r));
1398 socket_unwatch_control_pid(s);
1400 s->control_command_id = SOCKET_EXEC_START_POST;
1402 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1403 r = socket_spawn(s, s->control_command, &s->control_pid);
1405 log_warning_unit(UNIT(s)->id,
1406 "%s failed to run 'start-post' task: %s",
1407 UNIT(s)->id, strerror(-r));
1411 socket_set_state(s, SOCKET_START_POST);
1413 socket_enter_listening(s);
1418 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1421 static void socket_enter_start_pre(Socket *s) {
1425 socket_unwatch_control_pid(s);
1427 s->control_command_id = SOCKET_EXEC_START_PRE;
1429 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1430 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1433 socket_set_state(s, SOCKET_START_PRE);
1435 socket_enter_start_post(s);
1440 log_warning_unit(UNIT(s)->id,
1441 "%s failed to run 'start-pre' task: %s",
1442 UNIT(s)->id, strerror(-r));
1443 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1446 static void socket_enter_running(Socket *s, int cfd) {
1451 dbus_error_init(&error);
1453 /* We don't take connections anymore if we are supposed to
1454 * shut down anyway */
1455 if (unit_stop_pending(UNIT(s))) {
1456 log_debug_unit(UNIT(s)->id,
1457 "Suppressing connection request on %s since unit stop is scheduled.",
1461 close_nointr_nofail(cfd);
1463 /* Flush all sockets by closing and reopening them */
1464 socket_close_fds(s);
1466 r = socket_watch_fds(s);
1468 log_warning_unit(UNIT(s)->id,
1469 "%s failed to watch sockets: %s",
1470 UNIT(s)->id, strerror(-r));
1471 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1481 bool pending = false;
1483 /* If there's already a start pending don't bother to
1485 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1486 if (unit_active_or_pending(u)) {
1492 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1497 socket_set_state(s, SOCKET_RUNNING);
1499 char *prefix, *instance = NULL, *name;
1502 if (s->n_connections >= s->max_connections) {
1503 log_warning_unit(UNIT(s)->id,
1504 "%s: Too many incoming connections (%u)",
1505 UNIT(s)->id, s->n_connections);
1506 close_nointr_nofail(cfd);
1510 r = socket_instantiate_service(s);
1514 r = instance_from_socket(cfd, s->n_accepted, &instance);
1519 /* ENOTCONN is legitimate if TCP RST was received.
1520 * This connection is over, but the socket unit lives on. */
1521 close_nointr_nofail(cfd);
1525 prefix = unit_name_to_prefix(UNIT(s)->id);
1532 name = unit_name_build(prefix, instance, ".service");
1541 r = unit_add_name(UNIT_DEREF(s->service), name);
1547 service = SERVICE(UNIT_DEREF(s->service));
1548 unit_ref_unset(&s->service);
1551 UNIT(service)->no_gc = false;
1553 unit_choose_id(UNIT(service), name);
1556 r = service_set_socket_fd(service, cfd, s);
1561 s->n_connections ++;
1563 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1567 /* Notify clients about changed counters */
1568 unit_add_to_dbus_queue(UNIT(s));
1574 log_warning_unit(UNIT(s)->id,
1575 "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1577 cfd >= 0 ? "template" : "non-template",
1578 bus_error(&error, r));
1579 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1582 close_nointr_nofail(cfd);
1584 dbus_error_free(&error);
1587 static void socket_run_next(Socket *s) {
1591 assert(s->control_command);
1592 assert(s->control_command->command_next);
1594 socket_unwatch_control_pid(s);
1596 s->control_command = s->control_command->command_next;
1598 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1604 log_warning_unit(UNIT(s)->id,
1605 "%s failed to run next task: %s",
1606 UNIT(s)->id, strerror(-r));
1608 if (s->state == SOCKET_START_POST)
1609 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1610 else if (s->state == SOCKET_STOP_POST)
1611 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1613 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1616 static int socket_start(Unit *u) {
1617 Socket *s = SOCKET(u);
1621 /* We cannot fulfill this request right now, try again later
1623 if (s->state == SOCKET_STOP_PRE ||
1624 s->state == SOCKET_STOP_PRE_SIGKILL ||
1625 s->state == SOCKET_STOP_PRE_SIGTERM ||
1626 s->state == SOCKET_STOP_POST ||
1627 s->state == SOCKET_FINAL_SIGTERM ||
1628 s->state == SOCKET_FINAL_SIGKILL)
1631 if (s->state == SOCKET_START_PRE ||
1632 s->state == SOCKET_START_POST)
1635 /* Cannot run this without the service being around */
1636 if (UNIT_ISSET(s->service)) {
1639 service = SERVICE(UNIT_DEREF(s->service));
1641 if (UNIT(service)->load_state != UNIT_LOADED) {
1642 log_error_unit(u->id,
1643 "Socket service %s not loaded, refusing.",
1648 /* If the service is already active we cannot start the
1650 if (service->state != SERVICE_DEAD &&
1651 service->state != SERVICE_FAILED &&
1652 service->state != SERVICE_AUTO_RESTART) {
1653 log_error_unit(u->id,
1654 "Socket service %s already active, refusing.",
1659 #ifdef HAVE_SYSV_COMPAT
1660 if (service->is_sysv) {
1661 log_error_unit(u->id,
1662 "Using SysV services for socket activation is not supported. Refusing.");
1668 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1670 s->result = SOCKET_SUCCESS;
1671 socket_enter_start_pre(s);
1675 static int socket_stop(Unit *u) {
1676 Socket *s = SOCKET(u);
1681 if (s->state == SOCKET_STOP_PRE ||
1682 s->state == SOCKET_STOP_PRE_SIGTERM ||
1683 s->state == SOCKET_STOP_PRE_SIGKILL ||
1684 s->state == SOCKET_STOP_POST ||
1685 s->state == SOCKET_FINAL_SIGTERM ||
1686 s->state == SOCKET_FINAL_SIGKILL)
1689 /* If there's already something running we go directly into
1691 if (s->state == SOCKET_START_PRE ||
1692 s->state == SOCKET_START_POST) {
1693 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1697 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1699 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1703 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1704 Socket *s = SOCKET(u);
1712 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1713 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1714 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1716 if (s->control_pid > 0)
1717 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1719 if (s->control_command_id >= 0)
1720 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1722 LIST_FOREACH(port, p, s->ports) {
1728 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1731 if (p->type == SOCKET_SOCKET) {
1734 r = socket_address_print(&p->address, &t);
1738 if (socket_address_family(&p->address) == AF_NETLINK)
1739 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1741 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1743 } else if (p->type == SOCKET_SPECIAL)
1744 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1745 else if (p->type == SOCKET_MQUEUE)
1746 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1748 assert(p->type == SOCKET_FIFO);
1749 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1753 exec_context_serialize(&s->exec_context, UNIT(s), f);
1758 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1759 Socket *s = SOCKET(u);
1766 if (streq(key, "state")) {
1769 state = socket_state_from_string(value);
1771 log_debug_unit(u->id,
1772 "Failed to parse state value %s", value);
1774 s->deserialized_state = state;
1775 } else if (streq(key, "result")) {
1778 f = socket_result_from_string(value);
1780 log_debug_unit(u->id,
1781 "Failed to parse result value %s", value);
1782 else if (f != SOCKET_SUCCESS)
1785 } else if (streq(key, "n-accepted")) {
1788 if (safe_atou(value, &k) < 0)
1789 log_debug_unit(u->id,
1790 "Failed to parse n-accepted value %s", value);
1793 } else if (streq(key, "control-pid")) {
1796 if (parse_pid(value, &pid) < 0)
1797 log_debug_unit(u->id,
1798 "Failed to parse control-pid value %s", value);
1800 s->control_pid = pid;
1801 } else if (streq(key, "control-command")) {
1802 SocketExecCommand id;
1804 id = socket_exec_command_from_string(value);
1806 log_debug_unit(u->id,
1807 "Failed to parse exec-command value %s", value);
1809 s->control_command_id = id;
1810 s->control_command = s->exec_command[id];
1812 } else if (streq(key, "fifo")) {
1816 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1817 log_debug_unit(u->id,
1818 "Failed to parse fifo value %s", value);
1821 LIST_FOREACH(port, p, s->ports)
1822 if (p->type == SOCKET_FIFO &&
1823 streq_ptr(p->path, value+skip))
1828 close_nointr_nofail(p->fd);
1829 p->fd = fdset_remove(fds, fd);
1833 } else if (streq(key, "special")) {
1837 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1838 log_debug_unit(u->id,
1839 "Failed to parse special value %s", value);
1842 LIST_FOREACH(port, p, s->ports)
1843 if (p->type == SOCKET_SPECIAL &&
1844 streq_ptr(p->path, value+skip))
1849 close_nointr_nofail(p->fd);
1850 p->fd = fdset_remove(fds, fd);
1854 } else if (streq(key, "mqueue")) {
1858 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1859 log_debug_unit(u->id,
1860 "Failed to parse mqueue value %s", value);
1863 LIST_FOREACH(port, p, s->ports)
1864 if (p->type == SOCKET_MQUEUE &&
1865 streq_ptr(p->path, value+skip))
1870 close_nointr_nofail(p->fd);
1871 p->fd = fdset_remove(fds, fd);
1875 } else if (streq(key, "socket")) {
1876 int fd, type, skip = 0;
1879 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1880 log_debug_unit(u->id,
1881 "Failed to parse socket value %s", value);
1884 LIST_FOREACH(port, p, s->ports)
1885 if (socket_address_is(&p->address, value+skip, type))
1890 close_nointr_nofail(p->fd);
1891 p->fd = fdset_remove(fds, fd);
1895 } else if (streq(key, "netlink")) {
1899 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1900 log_debug_unit(u->id,
1901 "Failed to parse socket value %s", value);
1904 LIST_FOREACH(port, p, s->ports)
1905 if (socket_address_is_netlink(&p->address, value+skip))
1910 close_nointr_nofail(p->fd);
1911 p->fd = fdset_remove(fds, fd);
1914 } else if (streq(key, "tmp-dir")) {
1921 s->exec_context.tmp_dir = t;
1922 } else if (streq(key, "var-tmp-dir")) {
1929 s->exec_context.var_tmp_dir = t;
1931 log_debug_unit(UNIT(s)->id,
1932 "Unknown serialization key '%s'", key);
1937 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1938 Socket *s = SOCKET(u);
1943 LIST_FOREACH(port, p, s->ports) {
1947 if (p->type != SOCKET_SOCKET)
1953 FDSET_FOREACH(fd, fds, i) {
1954 if (socket_address_matches_fd(&p->address, fd)) {
1955 p->fd = fdset_remove(fds, fd);
1956 s->deserialized_state = SOCKET_LISTENING;
1965 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1968 return state_translation_table[SOCKET(u)->state];
1971 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1974 return socket_state_to_string(SOCKET(u)->state);
1977 const char* socket_port_type_to_string(SocketPort *p) {
1983 switch (p->address.type) {
1984 case SOCK_STREAM: return "Stream";
1985 case SOCK_DGRAM: return "Datagram";
1986 case SOCK_SEQPACKET: return "SequentialPacket";
1988 if (socket_address_family(&p->address) == AF_NETLINK)
1990 default: return "Invalid";
1992 case SOCKET_SPECIAL: return "Special";
1993 case SOCKET_MQUEUE: return "MessageQueue";
1994 case SOCKET_FIFO: return "FIFO";
1995 default: return NULL;
1999 _pure_ static bool socket_check_gc(Unit *u) {
2000 Socket *s = SOCKET(u);
2004 return s->n_connections > 0;
2007 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
2008 Socket *s = SOCKET(u);
2014 if (s->state != SOCKET_LISTENING)
2017 log_debug_unit(u->id, "Incoming traffic on %s", u->id);
2019 if (events != EPOLLIN) {
2021 if (events & EPOLLHUP)
2022 log_error_unit(u->id,
2023 "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
2026 log_error_unit(u->id,
2027 "%s: Got unexpected poll event (0x%x) on socket.",
2033 if (w->socket_accept) {
2036 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2042 log_error_unit(u->id,
2043 "Failed to accept socket: %m");
2050 socket_apply_socket_options(s, cfd);
2053 socket_enter_running(s, cfd);
2057 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2060 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2061 Socket *s = SOCKET(u);
2067 if (pid != s->control_pid)
2072 if (is_clean_exit(code, status, NULL))
2074 else if (code == CLD_EXITED)
2075 f = SOCKET_FAILURE_EXIT_CODE;
2076 else if (code == CLD_KILLED)
2077 f = SOCKET_FAILURE_SIGNAL;
2078 else if (code == CLD_DUMPED)
2079 f = SOCKET_FAILURE_CORE_DUMP;
2081 assert_not_reached("Unknown code");
2083 if (s->control_command) {
2084 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2086 if (s->control_command->ignore)
2090 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2092 "%s control process exited, code=%s status=%i",
2093 u->id, sigchld_code_to_string(code), status);
2095 if (f != SOCKET_SUCCESS)
2098 if (s->control_command &&
2099 s->control_command->command_next &&
2100 f == SOCKET_SUCCESS) {
2102 log_debug_unit(u->id,
2103 "%s running next command for state %s",
2104 u->id, socket_state_to_string(s->state));
2107 s->control_command = NULL;
2108 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2110 /* No further commands for this step, so let's figure
2111 * out what to do next */
2113 log_debug_unit(u->id,
2114 "%s got final SIGCHLD for state %s",
2115 u->id, socket_state_to_string(s->state));
2119 case SOCKET_START_PRE:
2120 if (f == SOCKET_SUCCESS)
2121 socket_enter_start_post(s);
2123 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2126 case SOCKET_START_POST:
2127 if (f == SOCKET_SUCCESS)
2128 socket_enter_listening(s);
2130 socket_enter_stop_pre(s, f);
2133 case SOCKET_STOP_PRE:
2134 case SOCKET_STOP_PRE_SIGTERM:
2135 case SOCKET_STOP_PRE_SIGKILL:
2136 socket_enter_stop_post(s, f);
2139 case SOCKET_STOP_POST:
2140 case SOCKET_FINAL_SIGTERM:
2141 case SOCKET_FINAL_SIGKILL:
2142 socket_enter_dead(s, f);
2146 assert_not_reached("Uh, control process died at wrong time.");
2150 /* Notify clients about changed exit status */
2151 unit_add_to_dbus_queue(u);
2154 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2155 Socket *s = SOCKET(u);
2158 assert(elapsed == 1);
2159 assert(w == &s->timer_watch);
2163 case SOCKET_START_PRE:
2164 log_warning_unit(u->id,
2165 "%s starting timed out. Terminating.", u->id);
2166 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2169 case SOCKET_START_POST:
2170 log_warning_unit(u->id,
2171 "%s starting timed out. Stopping.", u->id);
2172 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2175 case SOCKET_STOP_PRE:
2176 log_warning_unit(u->id,
2177 "%s stopping timed out. Terminating.", u->id);
2178 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2181 case SOCKET_STOP_PRE_SIGTERM:
2182 if (s->kill_context.send_sigkill) {
2183 log_warning_unit(u->id,
2184 "%s stopping timed out. Killing.", u->id);
2185 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2187 log_warning_unit(u->id,
2188 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2190 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2194 case SOCKET_STOP_PRE_SIGKILL:
2195 log_warning_unit(u->id,
2196 "%s still around after SIGKILL. Ignoring.", u->id);
2197 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2200 case SOCKET_STOP_POST:
2201 log_warning_unit(u->id,
2202 "%s stopping timed out (2). Terminating.", u->id);
2203 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2206 case SOCKET_FINAL_SIGTERM:
2207 if (s->kill_context.send_sigkill) {
2208 log_warning_unit(u->id,
2209 "%s stopping timed out (2). Killing.", u->id);
2210 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2212 log_warning_unit(u->id,
2213 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2215 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2219 case SOCKET_FINAL_SIGKILL:
2220 log_warning_unit(u->id,
2221 "%s still around after SIGKILL (2). Entering failed mode.",
2223 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2227 assert_not_reached("Timeout at wrong time.");
2231 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2240 /* Called from the service code for requesting our fds */
2243 LIST_FOREACH(port, p, s->ports)
2253 if (!(rfds = new(int, rn_fds)))
2257 LIST_FOREACH(port, p, s->ports)
2261 assert(k == rn_fds);
2269 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2272 /* The service is dead. Dang!
2274 * This is strictly for one-instance-for-all-connections
2277 if (s->state == SOCKET_RUNNING) {
2278 log_debug_unit(UNIT(s)->id,
2279 "%s got notified about service death (failed permanently: %s)",
2280 UNIT(s)->id, yes_no(failed_permanent));
2281 if (failed_permanent)
2282 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2284 socket_enter_listening(s);
2288 void socket_connection_unref(Socket *s) {
2291 /* The service is dead. Yay!
2293 * This is strictly for one-instance-per-connection
2296 assert(s->n_connections > 0);
2299 log_debug_unit(UNIT(s)->id,
2300 "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2303 static void socket_reset_failed(Unit *u) {
2304 Socket *s = SOCKET(u);
2308 if (s->state == SOCKET_FAILED)
2309 socket_set_state(s, SOCKET_DEAD);
2311 s->result = SOCKET_SUCCESS;
2314 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2315 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2318 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2319 [SOCKET_DEAD] = "dead",
2320 [SOCKET_START_PRE] = "start-pre",
2321 [SOCKET_START_POST] = "start-post",
2322 [SOCKET_LISTENING] = "listening",
2323 [SOCKET_RUNNING] = "running",
2324 [SOCKET_STOP_PRE] = "stop-pre",
2325 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2326 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2327 [SOCKET_STOP_POST] = "stop-post",
2328 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2329 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2330 [SOCKET_FAILED] = "failed"
2333 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2335 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2336 [SOCKET_EXEC_START_PRE] = "StartPre",
2337 [SOCKET_EXEC_START_POST] = "StartPost",
2338 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2339 [SOCKET_EXEC_STOP_POST] = "StopPost"
2342 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2344 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2345 [SOCKET_SUCCESS] = "success",
2346 [SOCKET_FAILURE_RESOURCES] = "resources",
2347 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2348 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2349 [SOCKET_FAILURE_SIGNAL] = "signal",
2350 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2351 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2354 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2356 const UnitVTable socket_vtable = {
2357 .object_size = sizeof(Socket),
2364 .exec_context_offset = offsetof(Socket, exec_context),
2365 .exec_section = "Socket",
2367 .init = socket_init,
2368 .done = socket_done,
2369 .load = socket_load,
2371 .kill = socket_kill,
2373 .coldplug = socket_coldplug,
2375 .dump = socket_dump,
2377 .start = socket_start,
2378 .stop = socket_stop,
2380 .serialize = socket_serialize,
2381 .deserialize_item = socket_deserialize_item,
2382 .distribute_fds = socket_distribute_fds,
2384 .active_state = socket_active_state,
2385 .sub_state_to_string = socket_sub_state_to_string,
2387 .check_gc = socket_check_gc,
2389 .fd_event = socket_fd_event,
2390 .sigchld_event = socket_sigchld_event,
2391 .timer_event = socket_timer_event,
2393 .reset_failed = socket_reset_failed,
2395 .bus_interface = "org.freedesktop.systemd1.Socket",
2396 .bus_message_handler = bus_socket_message_handler,
2397 .bus_invalidating_properties = bus_socket_invalidating_properties,
2399 .status_message_formats = {
2400 /*.starting_stopping = {
2401 [0] = "Starting socket %s...",
2402 [1] = "Stopping socket %s...",
2404 .finished_start_job = {
2405 [JOB_DONE] = "Listening on %s.",
2406 [JOB_FAILED] = "Failed to listen on %s.",
2407 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2408 [JOB_TIMEOUT] = "Timed out starting %s.",
2410 .finished_stop_job = {
2411 [JOB_DONE] = "Closed %s.",
2412 [JOB_FAILED] = "Failed stopping %s.",
2413 [JOB_TIMEOUT] = "Timed out stopping %s.",