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("%s: Too many incoming connections (%u)", UNIT(s)->id, 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 r = socket_address_print(&p->address, &t);
1709 if (socket_address_family(&p->address) == AF_NETLINK)
1710 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1712 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1714 } else if (p->type == SOCKET_SPECIAL)
1715 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1716 else if (p->type == SOCKET_MQUEUE)
1717 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1719 assert(p->type == SOCKET_FIFO);
1720 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1727 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1728 Socket *s = SOCKET(u);
1735 if (streq(key, "state")) {
1738 state = socket_state_from_string(value);
1740 log_debug("Failed to parse state value %s", value);
1742 s->deserialized_state = state;
1743 } else if (streq(key, "result")) {
1746 f = socket_result_from_string(value);
1748 log_debug("Failed to parse result value %s", value);
1749 else if (f != SOCKET_SUCCESS)
1752 } else if (streq(key, "n-accepted")) {
1755 if (safe_atou(value, &k) < 0)
1756 log_debug("Failed to parse n-accepted value %s", value);
1759 } else if (streq(key, "control-pid")) {
1762 if (parse_pid(value, &pid) < 0)
1763 log_debug("Failed to parse control-pid value %s", value);
1765 s->control_pid = pid;
1766 } else if (streq(key, "control-command")) {
1767 SocketExecCommand id;
1769 if ((id = socket_exec_command_from_string(value)) < 0)
1770 log_debug("Failed to parse exec-command value %s", value);
1772 s->control_command_id = id;
1773 s->control_command = s->exec_command[id];
1775 } else if (streq(key, "fifo")) {
1779 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1780 log_debug("Failed to parse fifo value %s", value);
1783 LIST_FOREACH(port, p, s->ports)
1784 if (p->type == SOCKET_FIFO &&
1785 streq_ptr(p->path, value+skip))
1790 close_nointr_nofail(p->fd);
1791 p->fd = fdset_remove(fds, fd);
1795 } else if (streq(key, "special")) {
1799 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1800 log_debug("Failed to parse special value %s", value);
1803 LIST_FOREACH(port, p, s->ports)
1804 if (p->type == SOCKET_SPECIAL &&
1805 streq_ptr(p->path, value+skip))
1810 close_nointr_nofail(p->fd);
1811 p->fd = fdset_remove(fds, fd);
1815 } else if (streq(key, "mqueue")) {
1819 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1820 log_debug("Failed to parse mqueue value %s", value);
1823 LIST_FOREACH(port, p, s->ports)
1824 if (p->type == SOCKET_MQUEUE &&
1825 streq_ptr(p->path, value+skip))
1830 close_nointr_nofail(p->fd);
1831 p->fd = fdset_remove(fds, fd);
1835 } else if (streq(key, "socket")) {
1836 int fd, type, skip = 0;
1839 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1840 log_debug("Failed to parse socket value %s", value);
1843 LIST_FOREACH(port, p, s->ports)
1844 if (socket_address_is(&p->address, value+skip, type))
1849 close_nointr_nofail(p->fd);
1850 p->fd = fdset_remove(fds, fd);
1854 } else if (streq(key, "netlink")) {
1858 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1859 log_debug("Failed to parse socket value %s", value);
1862 LIST_FOREACH(port, p, s->ports)
1863 if (socket_address_is_netlink(&p->address, value+skip))
1868 close_nointr_nofail(p->fd);
1869 p->fd = fdset_remove(fds, fd);
1874 log_debug("Unknown serialization key '%s'", key);
1879 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1880 Socket *s = SOCKET(u);
1885 LIST_FOREACH(port, p, s->ports) {
1889 if (p->type != SOCKET_SOCKET)
1895 FDSET_FOREACH(fd, fds, i) {
1896 if (socket_address_matches_fd(&p->address, fd)) {
1897 p->fd = fdset_remove(fds, fd);
1898 s->deserialized_state = SOCKET_LISTENING;
1907 static UnitActiveState socket_active_state(Unit *u) {
1910 return state_translation_table[SOCKET(u)->state];
1913 static const char *socket_sub_state_to_string(Unit *u) {
1916 return socket_state_to_string(SOCKET(u)->state);
1919 static bool socket_check_gc(Unit *u) {
1920 Socket *s = SOCKET(u);
1924 return s->n_connections > 0;
1927 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1928 Socket *s = SOCKET(u);
1934 if (s->state != SOCKET_LISTENING)
1937 log_debug("Incoming traffic on %s", u->id);
1939 if (events != EPOLLIN) {
1941 if (events & EPOLLHUP)
1942 log_error("%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.", u->id);
1944 log_error("%s: Got unexpected poll event (0x%x) on socket.", u->id, events);
1949 if (w->socket_accept) {
1952 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
1958 log_error("Failed to accept socket: %m");
1965 socket_apply_socket_options(s, cfd);
1968 socket_enter_running(s, cfd);
1972 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1975 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1976 Socket *s = SOCKET(u);
1982 if (pid != s->control_pid)
1987 if (is_clean_exit(code, status, NULL))
1989 else if (code == CLD_EXITED)
1990 f = SOCKET_FAILURE_EXIT_CODE;
1991 else if (code == CLD_KILLED)
1992 f = SOCKET_FAILURE_SIGNAL;
1993 else if (code == CLD_DUMPED)
1994 f = SOCKET_FAILURE_CORE_DUMP;
1996 assert_not_reached("Unknown code");
1998 if (s->control_command) {
1999 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2001 if (s->control_command->ignore)
2005 log_full(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2006 "%s control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
2008 if (f != SOCKET_SUCCESS)
2011 if (s->control_command &&
2012 s->control_command->command_next &&
2013 f == SOCKET_SUCCESS) {
2015 log_debug("%s running next command for state %s", u->id, socket_state_to_string(s->state));
2018 s->control_command = NULL;
2019 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2021 /* No further commands for this step, so let's figure
2022 * out what to do next */
2024 log_debug("%s got final SIGCHLD for state %s", u->id, socket_state_to_string(s->state));
2028 case SOCKET_START_PRE:
2029 if (f == SOCKET_SUCCESS)
2030 socket_enter_start_post(s);
2032 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2035 case SOCKET_START_POST:
2036 if (f == SOCKET_SUCCESS)
2037 socket_enter_listening(s);
2039 socket_enter_stop_pre(s, f);
2042 case SOCKET_STOP_PRE:
2043 case SOCKET_STOP_PRE_SIGTERM:
2044 case SOCKET_STOP_PRE_SIGKILL:
2045 socket_enter_stop_post(s, f);
2048 case SOCKET_STOP_POST:
2049 case SOCKET_FINAL_SIGTERM:
2050 case SOCKET_FINAL_SIGKILL:
2051 socket_enter_dead(s, f);
2055 assert_not_reached("Uh, control process died at wrong time.");
2059 /* Notify clients about changed exit status */
2060 unit_add_to_dbus_queue(u);
2063 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2064 Socket *s = SOCKET(u);
2067 assert(elapsed == 1);
2068 assert(w == &s->timer_watch);
2072 case SOCKET_START_PRE:
2073 log_warning("%s starting timed out. Terminating.", u->id);
2074 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2077 case SOCKET_START_POST:
2078 log_warning("%s starting timed out. Stopping.", u->id);
2079 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2082 case SOCKET_STOP_PRE:
2083 log_warning("%s stopping timed out. Terminating.", u->id);
2084 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2087 case SOCKET_STOP_PRE_SIGTERM:
2088 if (s->kill_context.send_sigkill) {
2089 log_warning("%s stopping timed out. Killing.", u->id);
2090 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2092 log_warning("%s stopping timed out. Skipping SIGKILL. Ignoring.", u->id);
2093 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2097 case SOCKET_STOP_PRE_SIGKILL:
2098 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
2099 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2102 case SOCKET_STOP_POST:
2103 log_warning("%s stopping timed out (2). Terminating.", u->id);
2104 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2107 case SOCKET_FINAL_SIGTERM:
2108 if (s->kill_context.send_sigkill) {
2109 log_warning("%s stopping timed out (2). Killing.", u->id);
2110 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2112 log_warning("%s stopping timed out (2). Skipping SIGKILL. Ignoring.", u->id);
2113 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2117 case SOCKET_FINAL_SIGKILL:
2118 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
2119 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2123 assert_not_reached("Timeout at wrong time.");
2127 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2136 /* Called from the service code for requesting our fds */
2139 LIST_FOREACH(port, p, s->ports)
2149 if (!(rfds = new(int, rn_fds)))
2153 LIST_FOREACH(port, p, s->ports)
2157 assert(k == rn_fds);
2165 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2168 /* The service is dead. Dang!
2170 * This is strictly for one-instance-for-all-connections
2173 if (s->state == SOCKET_RUNNING) {
2174 log_debug("%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2175 if (failed_permanent)
2176 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2178 socket_enter_listening(s);
2182 void socket_connection_unref(Socket *s) {
2185 /* The service is dead. Yay!
2187 * This is strictly for one-instance-per-connection
2190 assert(s->n_connections > 0);
2193 log_debug("%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2196 static void socket_reset_failed(Unit *u) {
2197 Socket *s = SOCKET(u);
2201 if (s->state == SOCKET_FAILED)
2202 socket_set_state(s, SOCKET_DEAD);
2204 s->result = SOCKET_SUCCESS;
2207 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2208 Socket *s = SOCKET(u);
2210 Set *pid_set = NULL;
2214 if (who == KILL_MAIN) {
2215 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Socket units have no main processes");
2219 if (s->control_pid <= 0 && who == KILL_CONTROL) {
2220 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2224 if (who == KILL_CONTROL || who == KILL_ALL)
2225 if (s->control_pid > 0)
2226 if (kill(s->control_pid, signo) < 0)
2229 if (who == KILL_ALL) {
2232 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2236 /* Exclude the control pid from being killed via the cgroup */
2237 if (s->control_pid > 0) {
2238 q = set_put(pid_set, LONG_TO_PTR(s->control_pid));
2245 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
2246 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2257 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2258 [SOCKET_DEAD] = "dead",
2259 [SOCKET_START_PRE] = "start-pre",
2260 [SOCKET_START_POST] = "start-post",
2261 [SOCKET_LISTENING] = "listening",
2262 [SOCKET_RUNNING] = "running",
2263 [SOCKET_STOP_PRE] = "stop-pre",
2264 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2265 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2266 [SOCKET_STOP_POST] = "stop-post",
2267 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2268 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2269 [SOCKET_FAILED] = "failed"
2272 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2274 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2275 [SOCKET_EXEC_START_PRE] = "StartPre",
2276 [SOCKET_EXEC_START_POST] = "StartPost",
2277 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2278 [SOCKET_EXEC_STOP_POST] = "StopPost"
2281 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2283 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2284 [SOCKET_SUCCESS] = "success",
2285 [SOCKET_FAILURE_RESOURCES] = "resources",
2286 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2287 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2288 [SOCKET_FAILURE_SIGNAL] = "signal",
2289 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2290 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2293 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2295 const UnitVTable socket_vtable = {
2296 .object_size = sizeof(Socket),
2297 .exec_context_offset = offsetof(Socket, exec_context),
2304 .init = socket_init,
2305 .done = socket_done,
2306 .load = socket_load,
2308 .kill = socket_kill,
2310 .coldplug = socket_coldplug,
2312 .dump = socket_dump,
2314 .start = socket_start,
2315 .stop = socket_stop,
2317 .serialize = socket_serialize,
2318 .deserialize_item = socket_deserialize_item,
2319 .distribute_fds = socket_distribute_fds,
2321 .active_state = socket_active_state,
2322 .sub_state_to_string = socket_sub_state_to_string,
2324 .check_gc = socket_check_gc,
2326 .fd_event = socket_fd_event,
2327 .sigchld_event = socket_sigchld_event,
2328 .timer_event = socket_timer_event,
2330 .reset_failed = socket_reset_failed,
2332 .bus_interface = "org.freedesktop.systemd1.Socket",
2333 .bus_message_handler = bus_socket_message_handler,
2334 .bus_invalidating_properties = bus_socket_invalidating_properties,
2336 .status_message_formats = {
2337 /*.starting_stopping = {
2338 [0] = "Starting socket %s...",
2339 [1] = "Stopping socket %s...",
2341 .finished_start_job = {
2342 [JOB_DONE] = "Listening on %s.",
2343 [JOB_FAILED] = "Failed to listen on %s.",
2344 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2345 [JOB_TIMEOUT] = "Timed out starting %s.",
2347 .finished_stop_job = {
2348 [JOB_DONE] = "Closed %s.",
2349 [JOB_FAILED] = "Failed stopping %s.",
2350 [JOB_TIMEOUT] = "Timed out stopping %s.",