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>
31 #ifdef HAVE_ATTR_XATTR_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 "bus-errors.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 static void socket_done(Unit *u) {
106 Socket *s = SOCKET(u);
111 while ((p = s->ports)) {
112 LIST_REMOVE(SocketPort, port, s->ports, p);
115 unit_unwatch_fd(UNIT(s), &p->fd_watch);
116 close_nointr_nofail(p->fd);
123 exec_context_done(&s->exec_context);
124 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
125 s->control_command = NULL;
127 socket_unwatch_control_pid(s);
129 unit_ref_unset(&s->service);
131 free(s->tcp_congestion);
132 s->tcp_congestion = NULL;
134 free(s->bind_to_device);
135 s->bind_to_device = NULL;
138 free(s->smack_ip_in);
139 free(s->smack_ip_out);
141 unit_unwatch_timer(u, &s->timer_watch);
144 static int socket_instantiate_service(Socket *s) {
151 /* This fills in s->service if it isn't filled in yet. For
152 * Accept=yes sockets we create the next connection service
153 * here. For Accept=no this is mostly a NOP since the service
154 * is figured out at load time anyway. */
156 if (UNIT_DEREF(s->service))
161 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
164 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
170 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
176 #ifdef HAVE_SYSV_COMPAT
177 if (SERVICE(u)->is_sysv) {
178 log_error("Using SysV services for socket activation is not supported. Refusing.");
184 unit_ref_set(&s->service, u);
186 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
189 static bool have_non_accept_socket(Socket *s) {
197 LIST_FOREACH(port, p, s->ports) {
199 if (p->type != SOCKET_SOCKET)
202 if (!socket_address_can_accept(&p->address))
209 static int socket_verify(Socket *s) {
212 if (UNIT(s)->load_state != UNIT_LOADED)
216 log_error("%s lacks Listen setting. Refusing.", UNIT(s)->id);
220 if (s->accept && have_non_accept_socket(s)) {
221 log_error("%s configured for accepting sockets, but sockets are non-accepting. Refusing.", UNIT(s)->id);
225 if (s->accept && s->max_connections <= 0) {
226 log_error("%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
230 if (s->accept && UNIT_DEREF(s->service)) {
231 log_error("Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
235 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
236 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
243 static bool socket_needs_mount(Socket *s, const char *prefix) {
248 LIST_FOREACH(port, p, s->ports) {
250 if (p->type == SOCKET_SOCKET) {
251 if (socket_address_needs_mount(&p->address, prefix))
253 } else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL) {
254 if (path_startswith(p->path, prefix))
262 int socket_add_one_mount_link(Socket *s, Mount *m) {
268 if (UNIT(s)->load_state != UNIT_LOADED ||
269 UNIT(m)->load_state != UNIT_LOADED)
272 if (!socket_needs_mount(s, m->where))
275 r = unit_add_two_dependencies(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
282 static int socket_add_mount_links(Socket *s) {
288 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_MOUNT]) {
289 r = socket_add_one_mount_link(s, MOUNT(other));
297 static int socket_add_device_link(Socket *s) {
303 if (!s->bind_to_device)
306 if (asprintf(&t, "/sys/subsystem/net/devices/%s", s->bind_to_device) < 0)
309 r = unit_add_node_link(UNIT(s), t, false);
315 static int socket_add_default_dependencies(Socket *s) {
319 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
320 if ((r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true)) < 0)
323 if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true)) < 0)
327 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
330 static bool socket_has_exec(Socket *s) {
334 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
335 if (s->exec_command[i])
341 static int socket_load(Unit *u) {
342 Socket *s = SOCKET(u);
346 assert(u->load_state == UNIT_STUB);
348 if ((r = unit_load_fragment_and_dropin(u)) < 0)
351 /* This is a new unit? Then let's add in some extras */
352 if (u->load_state == UNIT_LOADED) {
354 if (have_non_accept_socket(s)) {
356 if (!UNIT_DEREF(s->service)) {
359 r = unit_load_related_unit(u, ".service", &x);
363 unit_ref_set(&s->service, x);
366 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
371 if ((r = socket_add_mount_links(s)) < 0)
374 if ((r = socket_add_device_link(s)) < 0)
377 if (socket_has_exec(s))
378 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
381 if ((r = unit_add_default_cgroups(u)) < 0)
384 if (UNIT(s)->default_dependencies)
385 if ((r = socket_add_default_dependencies(s)) < 0)
388 r = unit_exec_context_defaults(u, &s->exec_context);
393 return socket_verify(s);
396 static const char* listen_lookup(int family, int type) {
398 if (family == AF_NETLINK)
399 return "ListenNetlink";
401 if (type == SOCK_STREAM)
402 return "ListenStream";
403 else if (type == SOCK_DGRAM)
404 return "ListenDatagram";
405 else if (type == SOCK_SEQPACKET)
406 return "ListenSequentialPacket";
408 assert_not_reached("Unknown socket type");
412 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
415 Socket *s = SOCKET(u);
423 p2 = strappend(prefix, "\t");
424 prefix2 = p2 ? p2 : prefix;
427 "%sSocket State: %s\n"
429 "%sBindIPv6Only: %s\n"
431 "%sSocketMode: %04o\n"
432 "%sDirectoryMode: %04o\n"
435 "%sTransparent: %s\n"
437 "%sPassCredentials: %s\n"
438 "%sPassSecurity: %s\n"
439 "%sTCPCongestion: %s\n",
440 prefix, socket_state_to_string(s->state),
441 prefix, socket_result_to_string(s->result),
442 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
444 prefix, s->socket_mode,
445 prefix, s->directory_mode,
446 prefix, yes_no(s->keep_alive),
447 prefix, yes_no(s->free_bind),
448 prefix, yes_no(s->transparent),
449 prefix, yes_no(s->broadcast),
450 prefix, yes_no(s->pass_cred),
451 prefix, yes_no(s->pass_sec),
452 prefix, strna(s->tcp_congestion));
454 if (s->control_pid > 0)
456 "%sControl PID: %lu\n",
457 prefix, (unsigned long) s->control_pid);
459 if (s->bind_to_device)
461 "%sBindToDevice: %s\n",
462 prefix, s->bind_to_device);
467 "%sNConnections: %u\n"
468 "%sMaxConnections: %u\n",
469 prefix, s->n_accepted,
470 prefix, s->n_connections,
471 prefix, s->max_connections);
473 if (s->priority >= 0)
476 prefix, s->priority);
478 if (s->receive_buffer > 0)
480 "%sReceiveBuffer: %zu\n",
481 prefix, s->receive_buffer);
483 if (s->send_buffer > 0)
485 "%sSendBuffer: %zu\n",
486 prefix, s->send_buffer);
498 if (s->pipe_size > 0)
501 prefix, s->pipe_size);
508 if (s->mq_maxmsg > 0)
510 "%sMessageQueueMaxMessages: %li\n",
511 prefix, s->mq_maxmsg);
513 if (s->mq_msgsize > 0)
515 "%sMessageQueueMessageSize: %li\n",
516 prefix, s->mq_msgsize);
520 "%sSmackLabel: %s\n",
525 "%sSmackLabelIPIn: %s\n",
526 prefix, s->smack_ip_in);
530 "%sSmackLabelIPOut: %s\n",
531 prefix, s->smack_ip_out);
533 LIST_FOREACH(port, p, s->ports) {
535 if (p->type == SOCKET_SOCKET) {
540 if ((r = socket_address_print(&p->address, &k)) < 0)
545 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
547 } else if (p->type == SOCKET_SPECIAL)
548 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
549 else if (p->type == SOCKET_MQUEUE)
550 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
552 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
555 exec_context_dump(&s->exec_context, f, prefix);
556 kill_context_dump(&s->kill_context, f, prefix);
558 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
559 if (!s->exec_command[c])
562 fprintf(f, "%s-> %s:\n",
563 prefix, socket_exec_command_to_string(c));
565 exec_command_dump_list(s->exec_command[c], f, prefix2);
571 static int instance_from_socket(int fd, unsigned nr, char **instance) {
576 struct sockaddr_un un;
577 struct sockaddr_in in;
578 struct sockaddr_in6 in6;
579 struct sockaddr_storage storage;
586 if (getsockname(fd, &local.sa, &l) < 0)
590 if (getpeername(fd, &remote.sa, &l) < 0)
593 switch (local.sa.sa_family) {
597 a = ntohl(local.in.sin_addr.s_addr),
598 b = ntohl(remote.in.sin_addr.s_addr);
601 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
603 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
604 ntohs(local.in.sin_port),
605 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
606 ntohs(remote.in.sin_port)) < 0)
613 static const unsigned char ipv4_prefix[] = {
614 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
617 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
618 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
620 *a = local.in6.sin6_addr.s6_addr+12,
621 *b = remote.in6.sin6_addr.s6_addr+12;
624 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
626 a[0], a[1], a[2], a[3],
627 ntohs(local.in6.sin6_port),
628 b[0], b[1], b[2], b[3],
629 ntohs(remote.in6.sin6_port)) < 0)
632 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
637 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
638 ntohs(local.in6.sin6_port),
639 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
640 ntohs(remote.in6.sin6_port)) < 0)
651 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
657 (unsigned long) ucred.pid,
658 (unsigned long) ucred.uid) < 0)
665 assert_not_reached("Unhandled socket type.");
672 static void socket_close_fds(Socket *s) {
677 LIST_FOREACH(port, p, s->ports) {
681 unit_unwatch_fd(UNIT(s), &p->fd_watch);
682 close_nointr_nofail(p->fd);
684 /* One little note: we should never delete any sockets
685 * in the file system here! After all some other
686 * process we spawned might still have a reference of
687 * this fd and wants to continue to use it. Therefore
688 * we delete sockets in the file system before we
689 * create a new one, not after we stopped using
696 static void socket_apply_socket_options(Socket *s, int fd) {
701 int b = s->keep_alive;
702 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
703 log_warning("SO_KEEPALIVE failed: %m");
708 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
709 log_warning("SO_BROADCAST failed: %m");
714 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
715 log_warning("SO_PASSCRED failed: %m");
720 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
721 log_warning("SO_PASSSEC failed: %m");
724 if (s->priority >= 0)
725 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
726 log_warning("SO_PRIORITY failed: %m");
728 if (s->receive_buffer > 0) {
729 int value = (int) s->receive_buffer;
731 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
733 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
734 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
735 log_warning("SO_RCVBUF failed: %m");
738 if (s->send_buffer > 0) {
739 int value = (int) s->send_buffer;
740 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
741 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
742 log_warning("SO_SNDBUF failed: %m");
746 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
747 log_warning("SO_MARK failed: %m");
750 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
751 log_warning("IP_TOS failed: %m");
753 if (s->ip_ttl >= 0) {
756 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
758 if (socket_ipv6_is_supported())
759 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
762 errno = EAFNOSUPPORT;
766 log_warning("IP_TTL/IPV6_UNICAST_HOPS failed: %m");
769 if (s->tcp_congestion)
770 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
771 log_warning("TCP_CONGESTION failed: %m");
773 #ifdef HAVE_ATTR_XATTR_H
775 if (fsetxattr(fd, "security.SMACK64IPIN", s->smack_ip_in, strlen(s->smack_ip_in), 0) < 0)
776 log_error("fsetxattr(\"security.SMACK64IPIN\"): %m");
779 if (fsetxattr(fd, "security.SMACK64IPOUT", s->smack_ip_out, strlen(s->smack_ip_out), 0) < 0)
780 log_error("fsetxattr(\"security.SMACK64IPOUT\"): %m");
784 static void socket_apply_fifo_options(Socket *s, int fd) {
788 if (s->pipe_size > 0)
789 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
790 log_warning("F_SETPIPE_SZ: %m");
792 #ifdef HAVE_ATTR_XATTR_H
794 if (fsetxattr(fd, "security.SMACK64", s->smack, strlen(s->smack), 0) < 0)
795 log_error("fsetxattr(\"security.SMACK64\"): %m");
799 static int fifo_address_create(
801 mode_t directory_mode,
812 mkdir_parents_label(path, directory_mode);
814 r = label_context_set(path, S_IFIFO);
818 /* Enforce the right access mode for the fifo */
819 old_mask = umask(~ socket_mode);
821 /* Include the original umask in our mask */
822 umask(~socket_mode | old_mask);
824 r = mkfifo(path, socket_mode);
827 if (r < 0 && errno != EEXIST) {
832 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
837 label_context_clear();
839 if (fstat(fd, &st) < 0) {
844 if (!S_ISFIFO(st.st_mode) ||
845 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
846 st.st_uid != getuid() ||
847 st.st_gid != getgid()) {
857 label_context_clear();
860 close_nointr_nofail(fd);
865 static int special_address_create(
875 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
880 if (fstat(fd, &st) < 0) {
885 /* Check whether this is a /proc, /sys or /dev file or char device */
886 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
896 close_nointr_nofail(fd);
901 static int mq_address_create(
911 struct mq_attr _attr, *attr = NULL;
916 if (maxmsg > 0 && msgsize > 0) {
918 _attr.mq_flags = O_NONBLOCK;
919 _attr.mq_maxmsg = maxmsg;
920 _attr.mq_msgsize = msgsize;
924 /* Enforce the right access mode for the mq */
925 old_mask = umask(~ mq_mode);
927 /* Include the original umask in our mask */
928 umask(~mq_mode | old_mask);
930 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
938 if (fstat(fd, &st) < 0) {
943 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
944 st.st_uid != getuid() ||
945 st.st_gid != getgid()) {
956 close_nointr_nofail(fd);
961 static int socket_open_fds(Socket *s) {
965 bool know_label = false;
969 LIST_FOREACH(port, p, s->ports) {
974 if (p->type == SOCKET_SOCKET) {
978 if ((r = socket_instantiate_service(s)) < 0)
981 if (UNIT_DEREF(s->service) &&
982 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
983 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
994 if ((r = socket_address_listen(
1007 socket_apply_socket_options(s, p->fd);
1009 } else if (p->type == SOCKET_SPECIAL) {
1011 if ((r = special_address_create(
1016 } else if (p->type == SOCKET_FIFO) {
1018 if ((r = fifo_address_create(
1025 socket_apply_fifo_options(s, p->fd);
1026 } else if (p->type == SOCKET_MQUEUE) {
1028 if ((r = mq_address_create(
1036 assert_not_reached("Unknown port type");
1043 socket_close_fds(s);
1048 static void socket_unwatch_fds(Socket *s) {
1053 LIST_FOREACH(port, p, s->ports) {
1057 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1061 static int socket_watch_fds(Socket *s) {
1067 LIST_FOREACH(port, p, s->ports) {
1071 p->fd_watch.socket_accept =
1073 p->type == SOCKET_SOCKET &&
1074 socket_address_can_accept(&p->address);
1076 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1083 socket_unwatch_fds(s);
1087 static void socket_set_state(Socket *s, SocketState state) {
1088 SocketState old_state;
1091 old_state = s->state;
1094 if (state != SOCKET_START_PRE &&
1095 state != SOCKET_START_POST &&
1096 state != SOCKET_STOP_PRE &&
1097 state != SOCKET_STOP_PRE_SIGTERM &&
1098 state != SOCKET_STOP_PRE_SIGKILL &&
1099 state != SOCKET_STOP_POST &&
1100 state != SOCKET_FINAL_SIGTERM &&
1101 state != SOCKET_FINAL_SIGKILL) {
1102 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1103 socket_unwatch_control_pid(s);
1104 s->control_command = NULL;
1105 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1108 if (state != SOCKET_LISTENING)
1109 socket_unwatch_fds(s);
1111 if (state != SOCKET_START_POST &&
1112 state != SOCKET_LISTENING &&
1113 state != SOCKET_RUNNING &&
1114 state != SOCKET_STOP_PRE &&
1115 state != SOCKET_STOP_PRE_SIGTERM &&
1116 state != SOCKET_STOP_PRE_SIGKILL)
1117 socket_close_fds(s);
1119 if (state != old_state)
1120 log_debug("%s changed %s -> %s",
1122 socket_state_to_string(old_state),
1123 socket_state_to_string(state));
1125 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1128 static int socket_coldplug(Unit *u) {
1129 Socket *s = SOCKET(u);
1133 assert(s->state == SOCKET_DEAD);
1135 if (s->deserialized_state != s->state) {
1137 if (s->deserialized_state == SOCKET_START_PRE ||
1138 s->deserialized_state == SOCKET_START_POST ||
1139 s->deserialized_state == SOCKET_STOP_PRE ||
1140 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1141 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1142 s->deserialized_state == SOCKET_STOP_POST ||
1143 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1144 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1146 if (s->control_pid <= 0)
1149 r = unit_watch_pid(UNIT(s), s->control_pid);
1153 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1158 if (s->deserialized_state == SOCKET_START_POST ||
1159 s->deserialized_state == SOCKET_LISTENING ||
1160 s->deserialized_state == SOCKET_RUNNING ||
1161 s->deserialized_state == SOCKET_STOP_PRE ||
1162 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1163 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1164 if ((r = socket_open_fds(s)) < 0)
1167 if (s->deserialized_state == SOCKET_LISTENING)
1168 if ((r = socket_watch_fds(s)) < 0)
1171 socket_set_state(s, s->deserialized_state);
1177 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1186 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1190 argv = unit_full_printf_strv(UNIT(s), c->argv);
1200 UNIT(s)->manager->environment,
1204 UNIT(s)->manager->confirm_spawn,
1205 UNIT(s)->cgroup_bondings,
1206 UNIT(s)->cgroup_attributes,
1216 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1217 /* FIXME: we need to do something here */
1225 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1230 static void socket_enter_dead(Socket *s, SocketResult f) {
1233 if (f != SOCKET_SUCCESS)
1236 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1239 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1241 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1245 if (f != SOCKET_SUCCESS)
1248 socket_unwatch_control_pid(s);
1250 s->control_command_id = SOCKET_EXEC_STOP_POST;
1252 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1253 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1256 socket_set_state(s, SOCKET_STOP_POST);
1258 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1263 log_warning("%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
1264 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1267 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1269 Set *pid_set = NULL;
1270 bool wait_for_exit = false;
1274 if (f != SOCKET_SUCCESS)
1277 if (s->kill_context.kill_mode != KILL_NONE) {
1278 int sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_FINAL_SIGTERM) ? s->kill_context.kill_signal : SIGKILL;
1280 if (s->control_pid > 0) {
1281 if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
1283 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
1285 wait_for_exit = true;
1288 if (s->kill_context.kill_mode == KILL_CONTROL_GROUP) {
1290 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
1295 /* Exclude the control pid from being killed via the cgroup */
1296 if (s->control_pid > 0)
1297 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
1300 r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
1302 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
1303 log_warning("Failed to kill control group: %s", strerror(-r));
1305 wait_for_exit = true;
1312 if (wait_for_exit) {
1313 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1317 socket_set_state(s, state);
1318 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1319 socket_enter_stop_post(s, SOCKET_SUCCESS);
1321 socket_enter_dead(s, SOCKET_SUCCESS);
1326 log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1328 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1329 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1331 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1337 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1341 if (f != SOCKET_SUCCESS)
1344 socket_unwatch_control_pid(s);
1346 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1348 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1349 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1352 socket_set_state(s, SOCKET_STOP_PRE);
1354 socket_enter_stop_post(s, SOCKET_SUCCESS);
1359 log_warning("%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1360 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1363 static void socket_enter_listening(Socket *s) {
1367 r = socket_watch_fds(s);
1369 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1373 socket_set_state(s, SOCKET_LISTENING);
1377 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1380 static void socket_enter_start_post(Socket *s) {
1384 r = socket_open_fds(s);
1386 log_warning("%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1390 socket_unwatch_control_pid(s);
1392 s->control_command_id = SOCKET_EXEC_START_POST;
1394 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1395 r = socket_spawn(s, s->control_command, &s->control_pid);
1397 log_warning("%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1401 socket_set_state(s, SOCKET_START_POST);
1403 socket_enter_listening(s);
1408 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1411 static void socket_enter_start_pre(Socket *s) {
1415 socket_unwatch_control_pid(s);
1417 s->control_command_id = SOCKET_EXEC_START_PRE;
1419 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1420 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1423 socket_set_state(s, SOCKET_START_PRE);
1425 socket_enter_start_post(s);
1430 log_warning("%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1431 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1434 static void socket_enter_running(Socket *s, int cfd) {
1439 dbus_error_init(&error);
1441 /* We don't take connections anymore if we are supposed to
1442 * shut down anyway */
1443 if (unit_pending_inactive(UNIT(s))) {
1444 log_debug("Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1447 close_nointr_nofail(cfd);
1449 /* Flush all sockets by closing and reopening them */
1450 socket_close_fds(s);
1452 r = socket_watch_fds(s);
1454 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1455 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1465 bool pending = false;
1467 /* If there's already a start pending don't bother to
1469 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1470 if (unit_pending_active(u)) {
1476 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1481 socket_set_state(s, SOCKET_RUNNING);
1483 char *prefix, *instance = NULL, *name;
1486 if (s->n_connections >= s->max_connections) {
1487 log_warning("Too many incoming connections (%u)", s->n_connections);
1488 close_nointr_nofail(cfd);
1492 r = socket_instantiate_service(s);
1496 r = instance_from_socket(cfd, s->n_accepted, &instance);
1501 /* ENOTCONN is legitimate if TCP RST was received.
1502 * This connection is over, but the socket unit lives on. */
1503 close_nointr_nofail(cfd);
1507 prefix = unit_name_to_prefix(UNIT(s)->id);
1514 name = unit_name_build(prefix, instance, ".service");
1523 r = unit_add_name(UNIT_DEREF(s->service), name);
1529 service = SERVICE(UNIT_DEREF(s->service));
1530 unit_ref_unset(&s->service);
1533 UNIT(service)->no_gc = false;
1535 unit_choose_id(UNIT(service), name);
1538 r = service_set_socket_fd(service, cfd, s);
1543 s->n_connections ++;
1545 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1549 /* Notify clients about changed counters */
1550 unit_add_to_dbus_queue(UNIT(s));
1556 log_warning("%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s", UNIT(s)->id, cfd >= 0 ? "template" : "non-template", bus_error(&error, r));
1557 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1560 close_nointr_nofail(cfd);
1562 dbus_error_free(&error);
1565 static void socket_run_next(Socket *s) {
1569 assert(s->control_command);
1570 assert(s->control_command->command_next);
1572 socket_unwatch_control_pid(s);
1574 s->control_command = s->control_command->command_next;
1576 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1582 log_warning("%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1584 if (s->state == SOCKET_START_POST)
1585 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1586 else if (s->state == SOCKET_STOP_POST)
1587 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1589 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1592 static int socket_start(Unit *u) {
1593 Socket *s = SOCKET(u);
1597 /* We cannot fulfill this request right now, try again later
1599 if (s->state == SOCKET_STOP_PRE ||
1600 s->state == SOCKET_STOP_PRE_SIGKILL ||
1601 s->state == SOCKET_STOP_PRE_SIGTERM ||
1602 s->state == SOCKET_STOP_POST ||
1603 s->state == SOCKET_FINAL_SIGTERM ||
1604 s->state == SOCKET_FINAL_SIGKILL)
1607 if (s->state == SOCKET_START_PRE ||
1608 s->state == SOCKET_START_POST)
1611 /* Cannot run this without the service being around */
1612 if (UNIT_DEREF(s->service)) {
1615 service = SERVICE(UNIT_DEREF(s->service));
1617 if (UNIT(service)->load_state != UNIT_LOADED) {
1618 log_error("Socket service %s not loaded, refusing.", UNIT(service)->id);
1622 /* If the service is already active we cannot start the
1624 if (service->state != SERVICE_DEAD &&
1625 service->state != SERVICE_FAILED &&
1626 service->state != SERVICE_AUTO_RESTART) {
1627 log_error("Socket service %s already active, refusing.", UNIT(service)->id);
1631 #ifdef HAVE_SYSV_COMPAT
1632 if (service->is_sysv) {
1633 log_error("Using SysV services for socket activation is not supported. Refusing.");
1639 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1641 s->result = SOCKET_SUCCESS;
1642 socket_enter_start_pre(s);
1646 static int socket_stop(Unit *u) {
1647 Socket *s = SOCKET(u);
1652 if (s->state == SOCKET_STOP_PRE ||
1653 s->state == SOCKET_STOP_PRE_SIGTERM ||
1654 s->state == SOCKET_STOP_PRE_SIGKILL ||
1655 s->state == SOCKET_STOP_POST ||
1656 s->state == SOCKET_FINAL_SIGTERM ||
1657 s->state == SOCKET_FINAL_SIGKILL)
1660 /* If there's already something running we go directly into
1662 if (s->state == SOCKET_START_PRE ||
1663 s->state == SOCKET_START_POST) {
1664 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1668 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1670 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1674 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1675 Socket *s = SOCKET(u);
1683 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1684 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1685 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1687 if (s->control_pid > 0)
1688 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1690 if (s->control_command_id >= 0)
1691 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1693 LIST_FOREACH(port, p, s->ports) {
1699 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1702 if (p->type == SOCKET_SOCKET) {
1705 if ((r = socket_address_print(&p->address, &t)) < 0)
1708 if (socket_address_family(&p->address) == AF_NETLINK)
1709 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1711 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1713 } else if (p->type == SOCKET_SPECIAL)
1714 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1716 assert(p->type == SOCKET_FIFO);
1717 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1724 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1725 Socket *s = SOCKET(u);
1732 if (streq(key, "state")) {
1735 if ((state = socket_state_from_string(value)) < 0)
1736 log_debug("Failed to parse state value %s", value);
1738 s->deserialized_state = state;
1739 } else if (streq(key, "result")) {
1742 f = socket_result_from_string(value);
1744 log_debug("Failed to parse result value %s", value);
1745 else if (f != SOCKET_SUCCESS)
1748 } else if (streq(key, "n-accepted")) {
1751 if (safe_atou(value, &k) < 0)
1752 log_debug("Failed to parse n-accepted value %s", value);
1755 } else if (streq(key, "control-pid")) {
1758 if (parse_pid(value, &pid) < 0)
1759 log_debug("Failed to parse control-pid value %s", value);
1761 s->control_pid = pid;
1762 } else if (streq(key, "control-command")) {
1763 SocketExecCommand id;
1765 if ((id = socket_exec_command_from_string(value)) < 0)
1766 log_debug("Failed to parse exec-command value %s", value);
1768 s->control_command_id = id;
1769 s->control_command = s->exec_command[id];
1771 } else if (streq(key, "fifo")) {
1775 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1776 log_debug("Failed to parse fifo value %s", value);
1779 LIST_FOREACH(port, p, s->ports)
1780 if (p->type == SOCKET_FIFO &&
1781 streq_ptr(p->path, value+skip))
1786 close_nointr_nofail(p->fd);
1787 p->fd = fdset_remove(fds, fd);
1791 } else if (streq(key, "special")) {
1795 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1796 log_debug("Failed to parse special value %s", value);
1799 LIST_FOREACH(port, p, s->ports)
1800 if (p->type == SOCKET_SPECIAL &&
1801 streq_ptr(p->path, value+skip))
1806 close_nointr_nofail(p->fd);
1807 p->fd = fdset_remove(fds, fd);
1811 } else if (streq(key, "socket")) {
1812 int fd, type, skip = 0;
1815 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1816 log_debug("Failed to parse socket value %s", value);
1819 LIST_FOREACH(port, p, s->ports)
1820 if (socket_address_is(&p->address, value+skip, type))
1825 close_nointr_nofail(p->fd);
1826 p->fd = fdset_remove(fds, fd);
1830 } else if (streq(key, "netlink")) {
1834 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1835 log_debug("Failed to parse socket value %s", value);
1838 LIST_FOREACH(port, p, s->ports)
1839 if (socket_address_is_netlink(&p->address, value+skip))
1844 close_nointr_nofail(p->fd);
1845 p->fd = fdset_remove(fds, fd);
1850 log_debug("Unknown serialization key '%s'", key);
1855 static UnitActiveState socket_active_state(Unit *u) {
1858 return state_translation_table[SOCKET(u)->state];
1861 static const char *socket_sub_state_to_string(Unit *u) {
1864 return socket_state_to_string(SOCKET(u)->state);
1867 static bool socket_check_gc(Unit *u) {
1868 Socket *s = SOCKET(u);
1872 return s->n_connections > 0;
1875 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1876 Socket *s = SOCKET(u);
1882 if (s->state != SOCKET_LISTENING)
1885 log_debug("Incoming traffic on %s", u->id);
1887 if (events != EPOLLIN) {
1889 if (events & EPOLLHUP)
1890 log_error("%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.", u->id);
1892 log_error("%s: Got unexpected poll event (0x%x) on socket.", u->id, events);
1897 if (w->socket_accept) {
1900 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
1906 log_error("Failed to accept socket: %m");
1913 socket_apply_socket_options(s, cfd);
1916 socket_enter_running(s, cfd);
1920 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1923 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1924 Socket *s = SOCKET(u);
1930 if (pid != s->control_pid)
1935 if (is_clean_exit(code, status, NULL))
1937 else if (code == CLD_EXITED)
1938 f = SOCKET_FAILURE_EXIT_CODE;
1939 else if (code == CLD_KILLED)
1940 f = SOCKET_FAILURE_SIGNAL;
1941 else if (code == CLD_DUMPED)
1942 f = SOCKET_FAILURE_CORE_DUMP;
1944 assert_not_reached("Unknown code");
1946 if (s->control_command) {
1947 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
1949 if (s->control_command->ignore)
1953 log_full(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1954 "%s control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1956 if (f != SOCKET_SUCCESS)
1959 if (s->control_command &&
1960 s->control_command->command_next &&
1961 f == SOCKET_SUCCESS) {
1963 log_debug("%s running next command for state %s", u->id, socket_state_to_string(s->state));
1966 s->control_command = NULL;
1967 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1969 /* No further commands for this step, so let's figure
1970 * out what to do next */
1972 log_debug("%s got final SIGCHLD for state %s", u->id, socket_state_to_string(s->state));
1976 case SOCKET_START_PRE:
1977 if (f == SOCKET_SUCCESS)
1978 socket_enter_start_post(s);
1980 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
1983 case SOCKET_START_POST:
1984 if (f == SOCKET_SUCCESS)
1985 socket_enter_listening(s);
1987 socket_enter_stop_pre(s, f);
1990 case SOCKET_STOP_PRE:
1991 case SOCKET_STOP_PRE_SIGTERM:
1992 case SOCKET_STOP_PRE_SIGKILL:
1993 socket_enter_stop_post(s, f);
1996 case SOCKET_STOP_POST:
1997 case SOCKET_FINAL_SIGTERM:
1998 case SOCKET_FINAL_SIGKILL:
1999 socket_enter_dead(s, f);
2003 assert_not_reached("Uh, control process died at wrong time.");
2007 /* Notify clients about changed exit status */
2008 unit_add_to_dbus_queue(u);
2011 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2012 Socket *s = SOCKET(u);
2015 assert(elapsed == 1);
2016 assert(w == &s->timer_watch);
2020 case SOCKET_START_PRE:
2021 log_warning("%s starting timed out. Terminating.", u->id);
2022 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2025 case SOCKET_START_POST:
2026 log_warning("%s starting timed out. Stopping.", u->id);
2027 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2030 case SOCKET_STOP_PRE:
2031 log_warning("%s stopping timed out. Terminating.", u->id);
2032 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2035 case SOCKET_STOP_PRE_SIGTERM:
2036 if (s->kill_context.send_sigkill) {
2037 log_warning("%s stopping timed out. Killing.", u->id);
2038 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2040 log_warning("%s stopping timed out. Skipping SIGKILL. Ignoring.", u->id);
2041 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2045 case SOCKET_STOP_PRE_SIGKILL:
2046 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
2047 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2050 case SOCKET_STOP_POST:
2051 log_warning("%s stopping timed out (2). Terminating.", u->id);
2052 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2055 case SOCKET_FINAL_SIGTERM:
2056 if (s->kill_context.send_sigkill) {
2057 log_warning("%s stopping timed out (2). Killing.", u->id);
2058 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2060 log_warning("%s stopping timed out (2). Skipping SIGKILL. Ignoring.", u->id);
2061 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2065 case SOCKET_FINAL_SIGKILL:
2066 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
2067 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2071 assert_not_reached("Timeout at wrong time.");
2075 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2084 /* Called from the service code for requesting our fds */
2087 LIST_FOREACH(port, p, s->ports)
2097 if (!(rfds = new(int, rn_fds)))
2101 LIST_FOREACH(port, p, s->ports)
2105 assert(k == rn_fds);
2113 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2116 /* The service is dead. Dang!
2118 * This is strictly for one-instance-for-all-connections
2121 if (s->state == SOCKET_RUNNING) {
2122 log_debug("%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2123 if (failed_permanent)
2124 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2126 socket_enter_listening(s);
2130 void socket_connection_unref(Socket *s) {
2133 /* The service is dead. Yay!
2135 * This is strictly for one-instance-per-connection
2138 assert(s->n_connections > 0);
2141 log_debug("%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2144 static void socket_reset_failed(Unit *u) {
2145 Socket *s = SOCKET(u);
2149 if (s->state == SOCKET_FAILED)
2150 socket_set_state(s, SOCKET_DEAD);
2152 s->result = SOCKET_SUCCESS;
2155 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2156 Socket *s = SOCKET(u);
2158 Set *pid_set = NULL;
2162 if (who == KILL_MAIN) {
2163 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Socket units have no main processes");
2167 if (s->control_pid <= 0 && who == KILL_CONTROL) {
2168 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2172 if (who == KILL_CONTROL || who == KILL_ALL)
2173 if (s->control_pid > 0)
2174 if (kill(s->control_pid, signo) < 0)
2177 if (who == KILL_ALL) {
2180 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2184 /* Exclude the control pid from being killed via the cgroup */
2185 if (s->control_pid > 0) {
2186 q = set_put(pid_set, LONG_TO_PTR(s->control_pid));
2193 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
2194 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2205 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2206 [SOCKET_DEAD] = "dead",
2207 [SOCKET_START_PRE] = "start-pre",
2208 [SOCKET_START_POST] = "start-post",
2209 [SOCKET_LISTENING] = "listening",
2210 [SOCKET_RUNNING] = "running",
2211 [SOCKET_STOP_PRE] = "stop-pre",
2212 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2213 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2214 [SOCKET_STOP_POST] = "stop-post",
2215 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2216 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2217 [SOCKET_FAILED] = "failed"
2220 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2222 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2223 [SOCKET_EXEC_START_PRE] = "StartPre",
2224 [SOCKET_EXEC_START_POST] = "StartPost",
2225 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2226 [SOCKET_EXEC_STOP_POST] = "StopPost"
2229 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2231 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2232 [SOCKET_SUCCESS] = "success",
2233 [SOCKET_FAILURE_RESOURCES] = "resources",
2234 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2235 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2236 [SOCKET_FAILURE_SIGNAL] = "signal",
2237 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2238 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2241 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2243 const UnitVTable socket_vtable = {
2244 .object_size = sizeof(Socket),
2245 .exec_context_offset = offsetof(Socket, exec_context),
2252 .init = socket_init,
2253 .done = socket_done,
2254 .load = socket_load,
2256 .kill = socket_kill,
2258 .coldplug = socket_coldplug,
2260 .dump = socket_dump,
2262 .start = socket_start,
2263 .stop = socket_stop,
2265 .serialize = socket_serialize,
2266 .deserialize_item = socket_deserialize_item,
2268 .active_state = socket_active_state,
2269 .sub_state_to_string = socket_sub_state_to_string,
2271 .check_gc = socket_check_gc,
2273 .fd_event = socket_fd_event,
2274 .sigchld_event = socket_sigchld_event,
2275 .timer_event = socket_timer_event,
2277 .reset_failed = socket_reset_failed,
2279 .bus_interface = "org.freedesktop.systemd1.Socket",
2280 .bus_message_handler = bus_socket_message_handler,
2281 .bus_invalidating_properties = bus_socket_invalidating_properties,
2283 .status_message_formats = {
2284 /*.starting_stopping = {
2285 [0] = "Starting socket %s...",
2286 [1] = "Stopping socket %s...",
2288 .finished_start_job = {
2289 [JOB_DONE] = "Listening on %s.",
2290 [JOB_FAILED] = "Failed to listen on %s.",
2291 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2292 [JOB_TIMEOUT] = "Timed out starting %s.",
2294 .finished_stop_job = {
2295 [JOB_DONE] = "Closed %s.",
2296 [JOB_FAILED] = "Failed stopping %s.",
2297 [JOB_TIMEOUT] = "Timed out stopping %s.",