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 if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
1152 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1156 if (s->deserialized_state == SOCKET_START_POST ||
1157 s->deserialized_state == SOCKET_LISTENING ||
1158 s->deserialized_state == SOCKET_RUNNING ||
1159 s->deserialized_state == SOCKET_STOP_PRE ||
1160 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1161 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1162 if ((r = socket_open_fds(s)) < 0)
1165 if (s->deserialized_state == SOCKET_LISTENING)
1166 if ((r = socket_watch_fds(s)) < 0)
1169 socket_set_state(s, s->deserialized_state);
1175 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1184 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1187 if (!(argv = unit_full_printf_strv(UNIT(s), c->argv))) {
1196 UNIT(s)->manager->environment,
1200 UNIT(s)->manager->confirm_spawn,
1201 UNIT(s)->cgroup_bondings,
1202 UNIT(s)->cgroup_attributes,
1212 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1213 /* FIXME: we need to do something here */
1221 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1226 static void socket_enter_dead(Socket *s, SocketResult f) {
1229 if (f != SOCKET_SUCCESS)
1232 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1235 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1237 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1241 if (f != SOCKET_SUCCESS)
1244 socket_unwatch_control_pid(s);
1246 s->control_command_id = SOCKET_EXEC_STOP_POST;
1248 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1249 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1252 socket_set_state(s, SOCKET_STOP_POST);
1254 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1259 log_warning("%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
1260 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1263 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1265 Set *pid_set = NULL;
1266 bool wait_for_exit = false;
1270 if (f != SOCKET_SUCCESS)
1273 if (s->kill_context.kill_mode != KILL_NONE) {
1274 int sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_FINAL_SIGTERM) ? s->kill_context.kill_signal : SIGKILL;
1276 if (s->control_pid > 0) {
1277 if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
1279 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
1281 wait_for_exit = true;
1284 if (s->kill_context.kill_mode == KILL_CONTROL_GROUP) {
1286 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
1291 /* Exclude the control pid from being killed via the cgroup */
1292 if (s->control_pid > 0)
1293 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
1296 r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
1298 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
1299 log_warning("Failed to kill control group: %s", strerror(-r));
1301 wait_for_exit = true;
1308 if (wait_for_exit) {
1309 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1312 socket_set_state(s, state);
1313 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1314 socket_enter_stop_post(s, SOCKET_SUCCESS);
1316 socket_enter_dead(s, SOCKET_SUCCESS);
1321 log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1323 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1324 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1326 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1332 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1336 if (f != SOCKET_SUCCESS)
1339 socket_unwatch_control_pid(s);
1341 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1343 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1344 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1347 socket_set_state(s, SOCKET_STOP_PRE);
1349 socket_enter_stop_post(s, SOCKET_SUCCESS);
1354 log_warning("%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1355 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1358 static void socket_enter_listening(Socket *s) {
1362 r = socket_watch_fds(s);
1364 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1368 socket_set_state(s, SOCKET_LISTENING);
1372 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1375 static void socket_enter_start_post(Socket *s) {
1379 r = socket_open_fds(s);
1381 log_warning("%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1385 socket_unwatch_control_pid(s);
1387 s->control_command_id = SOCKET_EXEC_START_POST;
1389 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1390 r = socket_spawn(s, s->control_command, &s->control_pid);
1392 log_warning("%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1396 socket_set_state(s, SOCKET_START_POST);
1398 socket_enter_listening(s);
1403 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1406 static void socket_enter_start_pre(Socket *s) {
1410 socket_unwatch_control_pid(s);
1412 s->control_command_id = SOCKET_EXEC_START_PRE;
1414 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1415 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1418 socket_set_state(s, SOCKET_START_PRE);
1420 socket_enter_start_post(s);
1425 log_warning("%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1426 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1429 static void socket_enter_running(Socket *s, int cfd) {
1434 dbus_error_init(&error);
1436 /* We don't take connections anymore if we are supposed to
1437 * shut down anyway */
1438 if (unit_pending_inactive(UNIT(s))) {
1439 log_debug("Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1442 close_nointr_nofail(cfd);
1444 /* Flush all sockets by closing and reopening them */
1445 socket_close_fds(s);
1447 r = socket_watch_fds(s);
1449 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1450 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1460 bool pending = false;
1462 /* If there's already a start pending don't bother to
1464 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1465 if (unit_pending_active(u)) {
1471 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1476 socket_set_state(s, SOCKET_RUNNING);
1478 char *prefix, *instance = NULL, *name;
1481 if (s->n_connections >= s->max_connections) {
1482 log_warning("Too many incoming connections (%u)", s->n_connections);
1483 close_nointr_nofail(cfd);
1487 r = socket_instantiate_service(s);
1491 r = instance_from_socket(cfd, s->n_accepted, &instance);
1496 /* ENOTCONN is legitimate if TCP RST was received.
1497 * This connection is over, but the socket unit lives on. */
1498 close_nointr_nofail(cfd);
1502 prefix = unit_name_to_prefix(UNIT(s)->id);
1509 name = unit_name_build(prefix, instance, ".service");
1518 r = unit_add_name(UNIT_DEREF(s->service), name);
1524 service = SERVICE(UNIT_DEREF(s->service));
1525 unit_ref_unset(&s->service);
1528 UNIT(service)->no_gc = false;
1530 unit_choose_id(UNIT(service), name);
1533 r = service_set_socket_fd(service, cfd, s);
1538 s->n_connections ++;
1540 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1544 /* Notify clients about changed counters */
1545 unit_add_to_dbus_queue(UNIT(s));
1551 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));
1552 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1555 close_nointr_nofail(cfd);
1557 dbus_error_free(&error);
1560 static void socket_run_next(Socket *s) {
1564 assert(s->control_command);
1565 assert(s->control_command->command_next);
1567 socket_unwatch_control_pid(s);
1569 s->control_command = s->control_command->command_next;
1571 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1577 log_warning("%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1579 if (s->state == SOCKET_START_POST)
1580 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1581 else if (s->state == SOCKET_STOP_POST)
1582 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1584 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1587 static int socket_start(Unit *u) {
1588 Socket *s = SOCKET(u);
1592 /* We cannot fulfill this request right now, try again later
1594 if (s->state == SOCKET_STOP_PRE ||
1595 s->state == SOCKET_STOP_PRE_SIGKILL ||
1596 s->state == SOCKET_STOP_PRE_SIGTERM ||
1597 s->state == SOCKET_STOP_POST ||
1598 s->state == SOCKET_FINAL_SIGTERM ||
1599 s->state == SOCKET_FINAL_SIGKILL)
1602 if (s->state == SOCKET_START_PRE ||
1603 s->state == SOCKET_START_POST)
1606 /* Cannot run this without the service being around */
1607 if (UNIT_DEREF(s->service)) {
1610 service = SERVICE(UNIT_DEREF(s->service));
1612 if (UNIT(service)->load_state != UNIT_LOADED) {
1613 log_error("Socket service %s not loaded, refusing.", UNIT(service)->id);
1617 /* If the service is already active we cannot start the
1619 if (service->state != SERVICE_DEAD &&
1620 service->state != SERVICE_FAILED &&
1621 service->state != SERVICE_AUTO_RESTART) {
1622 log_error("Socket service %s already active, refusing.", UNIT(service)->id);
1626 #ifdef HAVE_SYSV_COMPAT
1627 if (service->is_sysv) {
1628 log_error("Using SysV services for socket activation is not supported. Refusing.");
1634 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1636 s->result = SOCKET_SUCCESS;
1637 socket_enter_start_pre(s);
1641 static int socket_stop(Unit *u) {
1642 Socket *s = SOCKET(u);
1647 if (s->state == SOCKET_STOP_PRE ||
1648 s->state == SOCKET_STOP_PRE_SIGTERM ||
1649 s->state == SOCKET_STOP_PRE_SIGKILL ||
1650 s->state == SOCKET_STOP_POST ||
1651 s->state == SOCKET_FINAL_SIGTERM ||
1652 s->state == SOCKET_FINAL_SIGKILL)
1655 /* If there's already something running we go directly into
1657 if (s->state == SOCKET_START_PRE ||
1658 s->state == SOCKET_START_POST) {
1659 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1663 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1665 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1669 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1670 Socket *s = SOCKET(u);
1678 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1679 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1680 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1682 if (s->control_pid > 0)
1683 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1685 if (s->control_command_id >= 0)
1686 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1688 LIST_FOREACH(port, p, s->ports) {
1694 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1697 if (p->type == SOCKET_SOCKET) {
1700 if ((r = socket_address_print(&p->address, &t)) < 0)
1703 if (socket_address_family(&p->address) == AF_NETLINK)
1704 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1706 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1708 } else if (p->type == SOCKET_SPECIAL)
1709 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1711 assert(p->type == SOCKET_FIFO);
1712 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1719 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1720 Socket *s = SOCKET(u);
1727 if (streq(key, "state")) {
1730 if ((state = socket_state_from_string(value)) < 0)
1731 log_debug("Failed to parse state value %s", value);
1733 s->deserialized_state = state;
1734 } else if (streq(key, "result")) {
1737 f = socket_result_from_string(value);
1739 log_debug("Failed to parse result value %s", value);
1740 else if (f != SOCKET_SUCCESS)
1743 } else if (streq(key, "n-accepted")) {
1746 if (safe_atou(value, &k) < 0)
1747 log_debug("Failed to parse n-accepted value %s", value);
1750 } else if (streq(key, "control-pid")) {
1753 if (parse_pid(value, &pid) < 0)
1754 log_debug("Failed to parse control-pid value %s", value);
1756 s->control_pid = pid;
1757 } else if (streq(key, "control-command")) {
1758 SocketExecCommand id;
1760 if ((id = socket_exec_command_from_string(value)) < 0)
1761 log_debug("Failed to parse exec-command value %s", value);
1763 s->control_command_id = id;
1764 s->control_command = s->exec_command[id];
1766 } else if (streq(key, "fifo")) {
1770 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1771 log_debug("Failed to parse fifo value %s", value);
1774 LIST_FOREACH(port, p, s->ports)
1775 if (p->type == SOCKET_FIFO &&
1776 streq_ptr(p->path, value+skip))
1781 close_nointr_nofail(p->fd);
1782 p->fd = fdset_remove(fds, fd);
1786 } else if (streq(key, "special")) {
1790 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1791 log_debug("Failed to parse special value %s", value);
1794 LIST_FOREACH(port, p, s->ports)
1795 if (p->type == SOCKET_SPECIAL &&
1796 streq_ptr(p->path, value+skip))
1801 close_nointr_nofail(p->fd);
1802 p->fd = fdset_remove(fds, fd);
1806 } else if (streq(key, "socket")) {
1807 int fd, type, skip = 0;
1810 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1811 log_debug("Failed to parse socket value %s", value);
1814 LIST_FOREACH(port, p, s->ports)
1815 if (socket_address_is(&p->address, value+skip, type))
1820 close_nointr_nofail(p->fd);
1821 p->fd = fdset_remove(fds, fd);
1825 } else if (streq(key, "netlink")) {
1829 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1830 log_debug("Failed to parse socket value %s", value);
1833 LIST_FOREACH(port, p, s->ports)
1834 if (socket_address_is_netlink(&p->address, value+skip))
1839 close_nointr_nofail(p->fd);
1840 p->fd = fdset_remove(fds, fd);
1845 log_debug("Unknown serialization key '%s'", key);
1850 static UnitActiveState socket_active_state(Unit *u) {
1853 return state_translation_table[SOCKET(u)->state];
1856 static const char *socket_sub_state_to_string(Unit *u) {
1859 return socket_state_to_string(SOCKET(u)->state);
1862 static bool socket_check_gc(Unit *u) {
1863 Socket *s = SOCKET(u);
1867 return s->n_connections > 0;
1870 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1871 Socket *s = SOCKET(u);
1877 if (s->state != SOCKET_LISTENING)
1880 log_debug("Incoming traffic on %s", u->id);
1882 if (events != EPOLLIN) {
1884 if (events & EPOLLHUP)
1885 log_error("%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.", u->id);
1887 log_error("%s: Got unexpected poll event (0x%x) on socket.", u->id, events);
1892 if (w->socket_accept) {
1895 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
1901 log_error("Failed to accept socket: %m");
1908 socket_apply_socket_options(s, cfd);
1911 socket_enter_running(s, cfd);
1915 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1918 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1919 Socket *s = SOCKET(u);
1925 if (pid != s->control_pid)
1930 if (is_clean_exit(code, status, NULL))
1932 else if (code == CLD_EXITED)
1933 f = SOCKET_FAILURE_EXIT_CODE;
1934 else if (code == CLD_KILLED)
1935 f = SOCKET_FAILURE_SIGNAL;
1936 else if (code == CLD_DUMPED)
1937 f = SOCKET_FAILURE_CORE_DUMP;
1939 assert_not_reached("Unknown code");
1941 if (s->control_command) {
1942 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
1944 if (s->control_command->ignore)
1948 log_full(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1949 "%s control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1951 if (f != SOCKET_SUCCESS)
1954 if (s->control_command &&
1955 s->control_command->command_next &&
1956 f == SOCKET_SUCCESS) {
1958 log_debug("%s running next command for state %s", u->id, socket_state_to_string(s->state));
1961 s->control_command = NULL;
1962 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1964 /* No further commands for this step, so let's figure
1965 * out what to do next */
1967 log_debug("%s got final SIGCHLD for state %s", u->id, socket_state_to_string(s->state));
1971 case SOCKET_START_PRE:
1972 if (f == SOCKET_SUCCESS)
1973 socket_enter_start_post(s);
1975 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
1978 case SOCKET_START_POST:
1979 if (f == SOCKET_SUCCESS)
1980 socket_enter_listening(s);
1982 socket_enter_stop_pre(s, f);
1985 case SOCKET_STOP_PRE:
1986 case SOCKET_STOP_PRE_SIGTERM:
1987 case SOCKET_STOP_PRE_SIGKILL:
1988 socket_enter_stop_post(s, f);
1991 case SOCKET_STOP_POST:
1992 case SOCKET_FINAL_SIGTERM:
1993 case SOCKET_FINAL_SIGKILL:
1994 socket_enter_dead(s, f);
1998 assert_not_reached("Uh, control process died at wrong time.");
2002 /* Notify clients about changed exit status */
2003 unit_add_to_dbus_queue(u);
2006 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2007 Socket *s = SOCKET(u);
2010 assert(elapsed == 1);
2011 assert(w == &s->timer_watch);
2015 case SOCKET_START_PRE:
2016 log_warning("%s starting timed out. Terminating.", u->id);
2017 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2020 case SOCKET_START_POST:
2021 log_warning("%s starting timed out. Stopping.", u->id);
2022 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2025 case SOCKET_STOP_PRE:
2026 log_warning("%s stopping timed out. Terminating.", u->id);
2027 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2030 case SOCKET_STOP_PRE_SIGTERM:
2031 if (s->kill_context.send_sigkill) {
2032 log_warning("%s stopping timed out. Killing.", u->id);
2033 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2035 log_warning("%s stopping timed out. Skipping SIGKILL. Ignoring.", u->id);
2036 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2040 case SOCKET_STOP_PRE_SIGKILL:
2041 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
2042 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2045 case SOCKET_STOP_POST:
2046 log_warning("%s stopping timed out (2). Terminating.", u->id);
2047 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2050 case SOCKET_FINAL_SIGTERM:
2051 if (s->kill_context.send_sigkill) {
2052 log_warning("%s stopping timed out (2). Killing.", u->id);
2053 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2055 log_warning("%s stopping timed out (2). Skipping SIGKILL. Ignoring.", u->id);
2056 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2060 case SOCKET_FINAL_SIGKILL:
2061 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
2062 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2066 assert_not_reached("Timeout at wrong time.");
2070 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2079 /* Called from the service code for requesting our fds */
2082 LIST_FOREACH(port, p, s->ports)
2092 if (!(rfds = new(int, rn_fds)))
2096 LIST_FOREACH(port, p, s->ports)
2100 assert(k == rn_fds);
2108 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2111 /* The service is dead. Dang!
2113 * This is strictly for one-instance-for-all-connections
2116 if (s->state == SOCKET_RUNNING) {
2117 log_debug("%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2118 if (failed_permanent)
2119 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2121 socket_enter_listening(s);
2125 void socket_connection_unref(Socket *s) {
2128 /* The service is dead. Yay!
2130 * This is strictly for one-instance-per-connection
2133 assert(s->n_connections > 0);
2136 log_debug("%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2139 static void socket_reset_failed(Unit *u) {
2140 Socket *s = SOCKET(u);
2144 if (s->state == SOCKET_FAILED)
2145 socket_set_state(s, SOCKET_DEAD);
2147 s->result = SOCKET_SUCCESS;
2150 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2151 Socket *s = SOCKET(u);
2153 Set *pid_set = NULL;
2157 if (who == KILL_MAIN) {
2158 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Socket units have no main processes");
2162 if (s->control_pid <= 0 && who == KILL_CONTROL) {
2163 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2167 if (who == KILL_CONTROL || who == KILL_ALL)
2168 if (s->control_pid > 0)
2169 if (kill(s->control_pid, signo) < 0)
2172 if (who == KILL_ALL) {
2175 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2179 /* Exclude the control pid from being killed via the cgroup */
2180 if (s->control_pid > 0) {
2181 q = set_put(pid_set, LONG_TO_PTR(s->control_pid));
2188 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
2189 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2200 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2201 [SOCKET_DEAD] = "dead",
2202 [SOCKET_START_PRE] = "start-pre",
2203 [SOCKET_START_POST] = "start-post",
2204 [SOCKET_LISTENING] = "listening",
2205 [SOCKET_RUNNING] = "running",
2206 [SOCKET_STOP_PRE] = "stop-pre",
2207 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2208 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2209 [SOCKET_STOP_POST] = "stop-post",
2210 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2211 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2212 [SOCKET_FAILED] = "failed"
2215 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2217 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2218 [SOCKET_EXEC_START_PRE] = "StartPre",
2219 [SOCKET_EXEC_START_POST] = "StartPost",
2220 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2221 [SOCKET_EXEC_STOP_POST] = "StopPost"
2224 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2226 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2227 [SOCKET_SUCCESS] = "success",
2228 [SOCKET_FAILURE_RESOURCES] = "resources",
2229 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2230 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2231 [SOCKET_FAILURE_SIGNAL] = "signal",
2232 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2233 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2236 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2238 const UnitVTable socket_vtable = {
2239 .object_size = sizeof(Socket),
2240 .exec_context_offset = offsetof(Socket, exec_context),
2247 .init = socket_init,
2248 .done = socket_done,
2249 .load = socket_load,
2251 .kill = socket_kill,
2253 .coldplug = socket_coldplug,
2255 .dump = socket_dump,
2257 .start = socket_start,
2258 .stop = socket_stop,
2260 .serialize = socket_serialize,
2261 .deserialize_item = socket_deserialize_item,
2263 .active_state = socket_active_state,
2264 .sub_state_to_string = socket_sub_state_to_string,
2266 .check_gc = socket_check_gc,
2268 .fd_event = socket_fd_event,
2269 .sigchld_event = socket_sigchld_event,
2270 .timer_event = socket_timer_event,
2272 .reset_failed = socket_reset_failed,
2274 .bus_interface = "org.freedesktop.systemd1.Socket",
2275 .bus_message_handler = bus_socket_message_handler,
2276 .bus_invalidating_properties = bus_socket_invalidating_properties,
2278 .status_message_formats = {
2279 /*.starting_stopping = {
2280 [0] = "Starting socket %s...",
2281 [1] = "Stopping socket %s...",
2283 .finished_start_job = {
2284 [JOB_DONE] = "Listening on %s.",
2285 [JOB_FAILED] = "Failed to listen on %s.",
2286 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2287 [JOB_TIMEOUT] = "Timed out starting %s.",
2289 .finished_stop_job = {
2290 [JOB_DONE] = "Closed %s.",
2291 [JOB_FAILED] = "Failed stopping %s.",
2292 [JOB_TIMEOUT] = "Timed out stopping %s.",