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_unit(UNIT(s)->id,
217 "%s lacks Listen setting. Refusing.", UNIT(s)->id);
221 if (s->accept && have_non_accept_socket(s)) {
222 log_error_unit(UNIT(s)->id,
223 "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
228 if (s->accept && s->max_connections <= 0) {
229 log_error_unit(UNIT(s)->id,
230 "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
234 if (s->accept && UNIT_DEREF(s->service)) {
235 log_error_unit(UNIT(s)->id,
236 "Explicit service configuration for accepting sockets not supported on %s. Refusing.",
241 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
242 log_error_unit(UNIT(s)->id,
243 "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.",
251 static bool socket_needs_mount(Socket *s, const char *prefix) {
256 LIST_FOREACH(port, p, s->ports) {
258 if (p->type == SOCKET_SOCKET) {
259 if (socket_address_needs_mount(&p->address, prefix))
261 } else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL) {
262 if (path_startswith(p->path, prefix))
270 int socket_add_one_mount_link(Socket *s, Mount *m) {
276 if (UNIT(s)->load_state != UNIT_LOADED ||
277 UNIT(m)->load_state != UNIT_LOADED)
280 if (!socket_needs_mount(s, m->where))
283 r = unit_add_two_dependencies(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
290 static int socket_add_mount_links(Socket *s) {
296 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_MOUNT]) {
297 r = socket_add_one_mount_link(s, MOUNT(other));
305 static int socket_add_device_link(Socket *s) {
311 if (!s->bind_to_device)
314 if (asprintf(&t, "/sys/subsystem/net/devices/%s", s->bind_to_device) < 0)
317 r = unit_add_node_link(UNIT(s), t, false);
323 static int socket_add_default_dependencies(Socket *s) {
327 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
328 if ((r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true)) < 0)
331 if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true)) < 0)
335 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
338 static bool socket_has_exec(Socket *s) {
342 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
343 if (s->exec_command[i])
349 static int socket_load(Unit *u) {
350 Socket *s = SOCKET(u);
354 assert(u->load_state == UNIT_STUB);
356 if ((r = unit_load_fragment_and_dropin(u)) < 0)
359 /* This is a new unit? Then let's add in some extras */
360 if (u->load_state == UNIT_LOADED) {
362 if (have_non_accept_socket(s)) {
364 if (!UNIT_DEREF(s->service)) {
367 r = unit_load_related_unit(u, ".service", &x);
371 unit_ref_set(&s->service, x);
374 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
379 if ((r = socket_add_mount_links(s)) < 0)
382 if ((r = socket_add_device_link(s)) < 0)
385 if (socket_has_exec(s))
386 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
389 if ((r = unit_add_default_cgroups(u)) < 0)
392 if (UNIT(s)->default_dependencies)
393 if ((r = socket_add_default_dependencies(s)) < 0)
396 r = unit_exec_context_defaults(u, &s->exec_context);
401 return socket_verify(s);
404 static const char* listen_lookup(int family, int type) {
406 if (family == AF_NETLINK)
407 return "ListenNetlink";
409 if (type == SOCK_STREAM)
410 return "ListenStream";
411 else if (type == SOCK_DGRAM)
412 return "ListenDatagram";
413 else if (type == SOCK_SEQPACKET)
414 return "ListenSequentialPacket";
416 assert_not_reached("Unknown socket type");
420 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
423 Socket *s = SOCKET(u);
431 p2 = strappend(prefix, "\t");
432 prefix2 = p2 ? p2 : prefix;
435 "%sSocket State: %s\n"
437 "%sBindIPv6Only: %s\n"
439 "%sSocketMode: %04o\n"
440 "%sDirectoryMode: %04o\n"
443 "%sTransparent: %s\n"
445 "%sPassCredentials: %s\n"
446 "%sPassSecurity: %s\n"
447 "%sTCPCongestion: %s\n",
448 prefix, socket_state_to_string(s->state),
449 prefix, socket_result_to_string(s->result),
450 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
452 prefix, s->socket_mode,
453 prefix, s->directory_mode,
454 prefix, yes_no(s->keep_alive),
455 prefix, yes_no(s->free_bind),
456 prefix, yes_no(s->transparent),
457 prefix, yes_no(s->broadcast),
458 prefix, yes_no(s->pass_cred),
459 prefix, yes_no(s->pass_sec),
460 prefix, strna(s->tcp_congestion));
462 if (s->control_pid > 0)
464 "%sControl PID: %lu\n",
465 prefix, (unsigned long) s->control_pid);
467 if (s->bind_to_device)
469 "%sBindToDevice: %s\n",
470 prefix, s->bind_to_device);
475 "%sNConnections: %u\n"
476 "%sMaxConnections: %u\n",
477 prefix, s->n_accepted,
478 prefix, s->n_connections,
479 prefix, s->max_connections);
481 if (s->priority >= 0)
484 prefix, s->priority);
486 if (s->receive_buffer > 0)
488 "%sReceiveBuffer: %zu\n",
489 prefix, s->receive_buffer);
491 if (s->send_buffer > 0)
493 "%sSendBuffer: %zu\n",
494 prefix, s->send_buffer);
506 if (s->pipe_size > 0)
509 prefix, s->pipe_size);
516 if (s->mq_maxmsg > 0)
518 "%sMessageQueueMaxMessages: %li\n",
519 prefix, s->mq_maxmsg);
521 if (s->mq_msgsize > 0)
523 "%sMessageQueueMessageSize: %li\n",
524 prefix, s->mq_msgsize);
528 "%sSmackLabel: %s\n",
533 "%sSmackLabelIPIn: %s\n",
534 prefix, s->smack_ip_in);
538 "%sSmackLabelIPOut: %s\n",
539 prefix, s->smack_ip_out);
541 LIST_FOREACH(port, p, s->ports) {
543 if (p->type == SOCKET_SOCKET) {
548 if ((r = socket_address_print(&p->address, &k)) < 0)
553 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
555 } else if (p->type == SOCKET_SPECIAL)
556 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
557 else if (p->type == SOCKET_MQUEUE)
558 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
560 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
563 exec_context_dump(&s->exec_context, f, prefix);
564 kill_context_dump(&s->kill_context, f, prefix);
566 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
567 if (!s->exec_command[c])
570 fprintf(f, "%s-> %s:\n",
571 prefix, socket_exec_command_to_string(c));
573 exec_command_dump_list(s->exec_command[c], f, prefix2);
579 static int instance_from_socket(int fd, unsigned nr, char **instance) {
584 struct sockaddr_un un;
585 struct sockaddr_in in;
586 struct sockaddr_in6 in6;
587 struct sockaddr_storage storage;
594 if (getsockname(fd, &local.sa, &l) < 0)
598 if (getpeername(fd, &remote.sa, &l) < 0)
601 switch (local.sa.sa_family) {
605 a = ntohl(local.in.sin_addr.s_addr),
606 b = ntohl(remote.in.sin_addr.s_addr);
609 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
611 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
612 ntohs(local.in.sin_port),
613 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
614 ntohs(remote.in.sin_port)) < 0)
621 static const unsigned char ipv4_prefix[] = {
622 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
625 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
626 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
628 *a = local.in6.sin6_addr.s6_addr+12,
629 *b = remote.in6.sin6_addr.s6_addr+12;
632 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
634 a[0], a[1], a[2], a[3],
635 ntohs(local.in6.sin6_port),
636 b[0], b[1], b[2], b[3],
637 ntohs(remote.in6.sin6_port)) < 0)
640 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
645 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
646 ntohs(local.in6.sin6_port),
647 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
648 ntohs(remote.in6.sin6_port)) < 0)
659 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
665 (unsigned long) ucred.pid,
666 (unsigned long) ucred.uid) < 0)
673 assert_not_reached("Unhandled socket type.");
680 static void socket_close_fds(Socket *s) {
685 LIST_FOREACH(port, p, s->ports) {
689 unit_unwatch_fd(UNIT(s), &p->fd_watch);
690 close_nointr_nofail(p->fd);
692 /* One little note: we should never delete any sockets
693 * in the file system here! After all some other
694 * process we spawned might still have a reference of
695 * this fd and wants to continue to use it. Therefore
696 * we delete sockets in the file system before we
697 * create a new one, not after we stopped using
704 static void socket_apply_socket_options(Socket *s, int fd) {
709 int b = s->keep_alive;
710 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
711 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
716 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
717 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
722 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
723 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
728 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
729 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
732 if (s->priority >= 0)
733 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
734 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
736 if (s->receive_buffer > 0) {
737 int value = (int) s->receive_buffer;
739 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
741 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
742 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
743 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
746 if (s->send_buffer > 0) {
747 int value = (int) s->send_buffer;
748 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
749 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
750 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
754 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
755 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
758 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
759 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
761 if (s->ip_ttl >= 0) {
764 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
766 if (socket_ipv6_is_supported())
767 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
770 errno = EAFNOSUPPORT;
774 log_warning_unit(UNIT(s)->id,
775 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
778 if (s->tcp_congestion)
779 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
780 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
782 #ifdef HAVE_ATTR_XATTR_H
784 if (fsetxattr(fd, "security.SMACK64IPIN", s->smack_ip_in, strlen(s->smack_ip_in), 0) < 0)
785 log_error_unit(UNIT(s)->id,
786 "fsetxattr(\"security.SMACK64IPIN\"): %m");
789 if (fsetxattr(fd, "security.SMACK64IPOUT", s->smack_ip_out, strlen(s->smack_ip_out), 0) < 0)
790 log_error_unit(UNIT(s)->id,
791 "fsetxattr(\"security.SMACK64IPOUT\"): %m");
795 static void socket_apply_fifo_options(Socket *s, int fd) {
799 if (s->pipe_size > 0)
800 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
801 log_warning_unit(UNIT(s)->id,
804 #ifdef HAVE_ATTR_XATTR_H
806 if (fsetxattr(fd, "security.SMACK64", s->smack, strlen(s->smack), 0) < 0)
807 log_error_unit(UNIT(s)->id,
808 "fsetxattr(\"security.SMACK64\"): %m");
812 static int fifo_address_create(
814 mode_t directory_mode,
825 mkdir_parents_label(path, directory_mode);
827 r = label_context_set(path, S_IFIFO);
831 /* Enforce the right access mode for the fifo */
832 old_mask = umask(~ socket_mode);
834 /* Include the original umask in our mask */
835 umask(~socket_mode | old_mask);
837 r = mkfifo(path, socket_mode);
840 if (r < 0 && errno != EEXIST) {
845 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
850 label_context_clear();
852 if (fstat(fd, &st) < 0) {
857 if (!S_ISFIFO(st.st_mode) ||
858 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
859 st.st_uid != getuid() ||
860 st.st_gid != getgid()) {
870 label_context_clear();
873 close_nointr_nofail(fd);
878 static int special_address_create(
888 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
893 if (fstat(fd, &st) < 0) {
898 /* Check whether this is a /proc, /sys or /dev file or char device */
899 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
909 close_nointr_nofail(fd);
914 static int mq_address_create(
924 struct mq_attr _attr, *attr = NULL;
929 if (maxmsg > 0 && msgsize > 0) {
931 _attr.mq_flags = O_NONBLOCK;
932 _attr.mq_maxmsg = maxmsg;
933 _attr.mq_msgsize = msgsize;
937 /* Enforce the right access mode for the mq */
938 old_mask = umask(~ mq_mode);
940 /* Include the original umask in our mask */
941 umask(~mq_mode | old_mask);
943 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
951 if (fstat(fd, &st) < 0) {
956 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
957 st.st_uid != getuid() ||
958 st.st_gid != getgid()) {
969 close_nointr_nofail(fd);
974 static int socket_open_fds(Socket *s) {
978 bool know_label = false;
982 LIST_FOREACH(port, p, s->ports) {
987 if (p->type == SOCKET_SOCKET) {
991 if ((r = socket_instantiate_service(s)) < 0)
994 if (UNIT_DEREF(s->service) &&
995 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
996 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1007 if ((r = socket_address_listen(
1020 socket_apply_socket_options(s, p->fd);
1022 } else if (p->type == SOCKET_SPECIAL) {
1024 if ((r = special_address_create(
1029 } else if (p->type == SOCKET_FIFO) {
1031 if ((r = fifo_address_create(
1038 socket_apply_fifo_options(s, p->fd);
1039 } else if (p->type == SOCKET_MQUEUE) {
1041 if ((r = mq_address_create(
1049 assert_not_reached("Unknown port type");
1056 socket_close_fds(s);
1061 static void socket_unwatch_fds(Socket *s) {
1066 LIST_FOREACH(port, p, s->ports) {
1070 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1074 static int socket_watch_fds(Socket *s) {
1080 LIST_FOREACH(port, p, s->ports) {
1084 p->fd_watch.socket_accept =
1086 p->type == SOCKET_SOCKET &&
1087 socket_address_can_accept(&p->address);
1089 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1096 socket_unwatch_fds(s);
1100 static void socket_set_state(Socket *s, SocketState state) {
1101 SocketState old_state;
1104 old_state = s->state;
1107 if (state != SOCKET_START_PRE &&
1108 state != SOCKET_START_POST &&
1109 state != SOCKET_STOP_PRE &&
1110 state != SOCKET_STOP_PRE_SIGTERM &&
1111 state != SOCKET_STOP_PRE_SIGKILL &&
1112 state != SOCKET_STOP_POST &&
1113 state != SOCKET_FINAL_SIGTERM &&
1114 state != SOCKET_FINAL_SIGKILL) {
1115 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1116 socket_unwatch_control_pid(s);
1117 s->control_command = NULL;
1118 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1121 if (state != SOCKET_LISTENING)
1122 socket_unwatch_fds(s);
1124 if (state != SOCKET_START_POST &&
1125 state != SOCKET_LISTENING &&
1126 state != SOCKET_RUNNING &&
1127 state != SOCKET_STOP_PRE &&
1128 state != SOCKET_STOP_PRE_SIGTERM &&
1129 state != SOCKET_STOP_PRE_SIGKILL)
1130 socket_close_fds(s);
1132 if (state != old_state)
1133 log_debug_unit(UNIT(s)->id,
1134 "%s changed %s -> %s", UNIT(s)->id,
1135 socket_state_to_string(old_state),
1136 socket_state_to_string(state));
1138 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1141 static int socket_coldplug(Unit *u) {
1142 Socket *s = SOCKET(u);
1146 assert(s->state == SOCKET_DEAD);
1148 if (s->deserialized_state != s->state) {
1150 if (s->deserialized_state == SOCKET_START_PRE ||
1151 s->deserialized_state == SOCKET_START_POST ||
1152 s->deserialized_state == SOCKET_STOP_PRE ||
1153 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1154 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1155 s->deserialized_state == SOCKET_STOP_POST ||
1156 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1157 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1159 if (s->control_pid <= 0)
1162 r = unit_watch_pid(UNIT(s), s->control_pid);
1166 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1171 if (s->deserialized_state == SOCKET_START_POST ||
1172 s->deserialized_state == SOCKET_LISTENING ||
1173 s->deserialized_state == SOCKET_RUNNING ||
1174 s->deserialized_state == SOCKET_STOP_PRE ||
1175 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1176 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1177 if ((r = socket_open_fds(s)) < 0)
1180 if (s->deserialized_state == SOCKET_LISTENING)
1181 if ((r = socket_watch_fds(s)) < 0)
1184 socket_set_state(s, s->deserialized_state);
1190 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1199 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1203 argv = unit_full_printf_strv(UNIT(s), c->argv);
1213 UNIT(s)->manager->environment,
1217 UNIT(s)->manager->confirm_spawn,
1218 UNIT(s)->cgroup_bondings,
1219 UNIT(s)->cgroup_attributes,
1229 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1230 /* FIXME: we need to do something here */
1238 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1243 static void socket_enter_dead(Socket *s, SocketResult f) {
1246 if (f != SOCKET_SUCCESS)
1249 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1252 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1254 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1258 if (f != SOCKET_SUCCESS)
1261 socket_unwatch_control_pid(s);
1263 s->control_command_id = SOCKET_EXEC_STOP_POST;
1265 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1266 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1269 socket_set_state(s, SOCKET_STOP_POST);
1271 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1276 log_warning_unit(UNIT(s)->id,
1277 "%s failed to run 'stop-post' task: %s",
1278 UNIT(s)->id, strerror(-r));
1279 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1282 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1284 Set *pid_set = NULL;
1285 bool wait_for_exit = false;
1289 if (f != SOCKET_SUCCESS)
1292 if (s->kill_context.kill_mode != KILL_NONE) {
1293 int sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_FINAL_SIGTERM) ? s->kill_context.kill_signal : SIGKILL;
1295 if (s->control_pid > 0) {
1296 if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
1298 log_warning_unit(UNIT(s)->id,
1299 "Failed to kill control process %li: %m",
1300 (long) s->control_pid);
1302 wait_for_exit = true;
1305 if (s->kill_context.kill_mode == KILL_CONTROL_GROUP) {
1307 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
1312 /* Exclude the control pid from being killed via the cgroup */
1313 if (s->control_pid > 0)
1314 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
1317 r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
1319 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
1320 log_warning_unit(UNIT(s)->id,
1321 "Failed to kill control group: %s",
1324 wait_for_exit = true;
1331 if (wait_for_exit) {
1332 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1336 socket_set_state(s, state);
1337 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1338 socket_enter_stop_post(s, SOCKET_SUCCESS);
1340 socket_enter_dead(s, SOCKET_SUCCESS);
1345 log_warning_unit(UNIT(s)->id,
1346 "%s failed to kill processes: %s",
1347 UNIT(s)->id, strerror(-r));
1349 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1350 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1352 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1358 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1362 if (f != SOCKET_SUCCESS)
1365 socket_unwatch_control_pid(s);
1367 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1369 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1370 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1373 socket_set_state(s, SOCKET_STOP_PRE);
1375 socket_enter_stop_post(s, SOCKET_SUCCESS);
1380 log_warning_unit(UNIT(s)->id,
1381 "%s failed to run 'stop-pre' task: %s",
1382 UNIT(s)->id, strerror(-r));
1383 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1386 static void socket_enter_listening(Socket *s) {
1390 r = socket_watch_fds(s);
1392 log_warning_unit(UNIT(s)->id,
1393 "%s failed to watch sockets: %s",
1394 UNIT(s)->id, strerror(-r));
1398 socket_set_state(s, SOCKET_LISTENING);
1402 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1405 static void socket_enter_start_post(Socket *s) {
1409 r = socket_open_fds(s);
1411 log_warning_unit(UNIT(s)->id,
1412 "%s failed to listen on sockets: %s",
1413 UNIT(s)->id, strerror(-r));
1417 socket_unwatch_control_pid(s);
1419 s->control_command_id = SOCKET_EXEC_START_POST;
1421 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1422 r = socket_spawn(s, s->control_command, &s->control_pid);
1424 log_warning_unit(UNIT(s)->id,
1425 "%s failed to run 'start-post' task: %s",
1426 UNIT(s)->id, strerror(-r));
1430 socket_set_state(s, SOCKET_START_POST);
1432 socket_enter_listening(s);
1437 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1440 static void socket_enter_start_pre(Socket *s) {
1444 socket_unwatch_control_pid(s);
1446 s->control_command_id = SOCKET_EXEC_START_PRE;
1448 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1449 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1452 socket_set_state(s, SOCKET_START_PRE);
1454 socket_enter_start_post(s);
1459 log_warning_unit(UNIT(s)->id,
1460 "%s failed to run 'start-pre' task: %s",
1461 UNIT(s)->id, strerror(-r));
1462 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1465 static void socket_enter_running(Socket *s, int cfd) {
1470 dbus_error_init(&error);
1472 /* We don't take connections anymore if we are supposed to
1473 * shut down anyway */
1474 if (unit_pending_inactive(UNIT(s))) {
1475 log_debug_unit(UNIT(s)->id,
1476 "Suppressing connection request on %s since unit stop is scheduled.",
1480 close_nointr_nofail(cfd);
1482 /* Flush all sockets by closing and reopening them */
1483 socket_close_fds(s);
1485 r = socket_watch_fds(s);
1487 log_warning_unit(UNIT(s)->id,
1488 "%s failed to watch sockets: %s",
1489 UNIT(s)->id, strerror(-r));
1490 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1500 bool pending = false;
1502 /* If there's already a start pending don't bother to
1504 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1505 if (unit_pending_active(u)) {
1511 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1516 socket_set_state(s, SOCKET_RUNNING);
1518 char *prefix, *instance = NULL, *name;
1521 if (s->n_connections >= s->max_connections) {
1522 log_warning_unit(UNIT(s)->id,
1523 "%s: Too many incoming connections (%u)",
1524 UNIT(s)->id, s->n_connections);
1525 close_nointr_nofail(cfd);
1529 r = socket_instantiate_service(s);
1533 r = instance_from_socket(cfd, s->n_accepted, &instance);
1538 /* ENOTCONN is legitimate if TCP RST was received.
1539 * This connection is over, but the socket unit lives on. */
1540 close_nointr_nofail(cfd);
1544 prefix = unit_name_to_prefix(UNIT(s)->id);
1551 name = unit_name_build(prefix, instance, ".service");
1560 r = unit_add_name(UNIT_DEREF(s->service), name);
1566 service = SERVICE(UNIT_DEREF(s->service));
1567 unit_ref_unset(&s->service);
1570 UNIT(service)->no_gc = false;
1572 unit_choose_id(UNIT(service), name);
1575 r = service_set_socket_fd(service, cfd, s);
1580 s->n_connections ++;
1582 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1586 /* Notify clients about changed counters */
1587 unit_add_to_dbus_queue(UNIT(s));
1593 log_warning_unit(UNIT(s)->id,
1594 "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1596 cfd >= 0 ? "template" : "non-template",
1597 bus_error(&error, r));
1598 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1601 close_nointr_nofail(cfd);
1603 dbus_error_free(&error);
1606 static void socket_run_next(Socket *s) {
1610 assert(s->control_command);
1611 assert(s->control_command->command_next);
1613 socket_unwatch_control_pid(s);
1615 s->control_command = s->control_command->command_next;
1617 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1623 log_warning_unit(UNIT(s)->id,
1624 "%s failed to run next task: %s",
1625 UNIT(s)->id, strerror(-r));
1627 if (s->state == SOCKET_START_POST)
1628 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1629 else if (s->state == SOCKET_STOP_POST)
1630 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1632 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1635 static int socket_start(Unit *u) {
1636 Socket *s = SOCKET(u);
1640 /* We cannot fulfill this request right now, try again later
1642 if (s->state == SOCKET_STOP_PRE ||
1643 s->state == SOCKET_STOP_PRE_SIGKILL ||
1644 s->state == SOCKET_STOP_PRE_SIGTERM ||
1645 s->state == SOCKET_STOP_POST ||
1646 s->state == SOCKET_FINAL_SIGTERM ||
1647 s->state == SOCKET_FINAL_SIGKILL)
1650 if (s->state == SOCKET_START_PRE ||
1651 s->state == SOCKET_START_POST)
1654 /* Cannot run this without the service being around */
1655 if (UNIT_DEREF(s->service)) {
1658 service = SERVICE(UNIT_DEREF(s->service));
1660 if (UNIT(service)->load_state != UNIT_LOADED) {
1661 log_error_unit(UNIT(service)->id,
1662 "Socket service %s not loaded, refusing.",
1667 /* If the service is already active we cannot start the
1669 if (service->state != SERVICE_DEAD &&
1670 service->state != SERVICE_FAILED &&
1671 service->state != SERVICE_AUTO_RESTART) {
1672 log_error_unit(UNIT(service)->id,
1673 "Socket service %s already active, refusing.",
1678 #ifdef HAVE_SYSV_COMPAT
1679 if (service->is_sysv) {
1680 log_error_unit(UNIT(s)->id,
1681 "Using SysV services for socket activation is not supported. Refusing.");
1687 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1689 s->result = SOCKET_SUCCESS;
1690 socket_enter_start_pre(s);
1694 static int socket_stop(Unit *u) {
1695 Socket *s = SOCKET(u);
1700 if (s->state == SOCKET_STOP_PRE ||
1701 s->state == SOCKET_STOP_PRE_SIGTERM ||
1702 s->state == SOCKET_STOP_PRE_SIGKILL ||
1703 s->state == SOCKET_STOP_POST ||
1704 s->state == SOCKET_FINAL_SIGTERM ||
1705 s->state == SOCKET_FINAL_SIGKILL)
1708 /* If there's already something running we go directly into
1710 if (s->state == SOCKET_START_PRE ||
1711 s->state == SOCKET_START_POST) {
1712 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1716 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1718 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1722 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1723 Socket *s = SOCKET(u);
1731 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1732 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1733 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1735 if (s->control_pid > 0)
1736 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1738 if (s->control_command_id >= 0)
1739 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1741 LIST_FOREACH(port, p, s->ports) {
1747 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1750 if (p->type == SOCKET_SOCKET) {
1753 r = socket_address_print(&p->address, &t);
1757 if (socket_address_family(&p->address) == AF_NETLINK)
1758 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1760 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1762 } else if (p->type == SOCKET_SPECIAL)
1763 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1764 else if (p->type == SOCKET_MQUEUE)
1765 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1767 assert(p->type == SOCKET_FIFO);
1768 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1775 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1776 Socket *s = SOCKET(u);
1783 if (streq(key, "state")) {
1786 state = socket_state_from_string(value);
1788 log_debug_unit(u->id,
1789 "Failed to parse state value %s", value);
1791 s->deserialized_state = state;
1792 } else if (streq(key, "result")) {
1795 f = socket_result_from_string(value);
1797 log_debug_unit(u->id,
1798 "Failed to parse result value %s", value);
1799 else if (f != SOCKET_SUCCESS)
1802 } else if (streq(key, "n-accepted")) {
1805 if (safe_atou(value, &k) < 0)
1806 log_debug_unit(u->id,
1807 "Failed to parse n-accepted value %s", value);
1810 } else if (streq(key, "control-pid")) {
1813 if (parse_pid(value, &pid) < 0)
1814 log_debug_unit(u->id,
1815 "Failed to parse control-pid value %s", value);
1817 s->control_pid = pid;
1818 } else if (streq(key, "control-command")) {
1819 SocketExecCommand id;
1821 id = socket_exec_command_from_string(value);
1823 log_debug_unit(u->id,
1824 "Failed to parse exec-command value %s", value);
1826 s->control_command_id = id;
1827 s->control_command = s->exec_command[id];
1829 } else if (streq(key, "fifo")) {
1833 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1834 log_debug_unit(u->id,
1835 "Failed to parse fifo value %s", value);
1838 LIST_FOREACH(port, p, s->ports)
1839 if (p->type == SOCKET_FIFO &&
1840 streq_ptr(p->path, value+skip))
1845 close_nointr_nofail(p->fd);
1846 p->fd = fdset_remove(fds, fd);
1850 } else if (streq(key, "special")) {
1854 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1855 log_debug_unit(u->id,
1856 "Failed to parse special value %s", value);
1859 LIST_FOREACH(port, p, s->ports)
1860 if (p->type == SOCKET_SPECIAL &&
1861 streq_ptr(p->path, value+skip))
1866 close_nointr_nofail(p->fd);
1867 p->fd = fdset_remove(fds, fd);
1871 } else if (streq(key, "mqueue")) {
1875 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1876 log_debug_unit(u->id,
1877 "Failed to parse mqueue value %s", value);
1880 LIST_FOREACH(port, p, s->ports)
1881 if (p->type == SOCKET_MQUEUE &&
1882 streq_ptr(p->path, value+skip))
1887 close_nointr_nofail(p->fd);
1888 p->fd = fdset_remove(fds, fd);
1892 } else if (streq(key, "socket")) {
1893 int fd, type, skip = 0;
1896 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1897 log_debug_unit(u->id,
1898 "Failed to parse socket value %s", value);
1901 LIST_FOREACH(port, p, s->ports)
1902 if (socket_address_is(&p->address, value+skip, type))
1907 close_nointr_nofail(p->fd);
1908 p->fd = fdset_remove(fds, fd);
1912 } else if (streq(key, "netlink")) {
1916 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1917 log_debug_unit(u->id,
1918 "Failed to parse socket value %s", value);
1921 LIST_FOREACH(port, p, s->ports)
1922 if (socket_address_is_netlink(&p->address, value+skip))
1927 close_nointr_nofail(p->fd);
1928 p->fd = fdset_remove(fds, fd);
1933 log_debug_unit(UNIT(s)->id,
1934 "Unknown serialization key '%s'", key);
1939 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1940 Socket *s = SOCKET(u);
1945 LIST_FOREACH(port, p, s->ports) {
1949 if (p->type != SOCKET_SOCKET)
1955 FDSET_FOREACH(fd, fds, i) {
1956 if (socket_address_matches_fd(&p->address, fd)) {
1957 p->fd = fdset_remove(fds, fd);
1958 s->deserialized_state = SOCKET_LISTENING;
1967 static UnitActiveState socket_active_state(Unit *u) {
1970 return state_translation_table[SOCKET(u)->state];
1973 static const char *socket_sub_state_to_string(Unit *u) {
1976 return socket_state_to_string(SOCKET(u)->state);
1979 static bool socket_check_gc(Unit *u) {
1980 Socket *s = SOCKET(u);
1984 return s->n_connections > 0;
1987 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1988 Socket *s = SOCKET(u);
1994 if (s->state != SOCKET_LISTENING)
1997 log_debug_unit(u->id, "Incoming traffic on %s", u->id);
1999 if (events != EPOLLIN) {
2001 if (events & EPOLLHUP)
2002 log_error_unit(u->id,
2003 "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
2006 log_error_unit(u->id,
2007 "%s: Got unexpected poll event (0x%x) on socket.",
2013 if (w->socket_accept) {
2016 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2022 log_error_unit(u->id,
2023 "Failed to accept socket: %m");
2030 socket_apply_socket_options(s, cfd);
2033 socket_enter_running(s, cfd);
2037 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2040 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2041 Socket *s = SOCKET(u);
2047 if (pid != s->control_pid)
2052 if (is_clean_exit(code, status, NULL))
2054 else if (code == CLD_EXITED)
2055 f = SOCKET_FAILURE_EXIT_CODE;
2056 else if (code == CLD_KILLED)
2057 f = SOCKET_FAILURE_SIGNAL;
2058 else if (code == CLD_DUMPED)
2059 f = SOCKET_FAILURE_CORE_DUMP;
2061 assert_not_reached("Unknown code");
2063 if (s->control_command) {
2064 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2066 if (s->control_command->ignore)
2070 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2072 "%s control process exited, code=%s status=%i",
2073 u->id, sigchld_code_to_string(code), status);
2075 if (f != SOCKET_SUCCESS)
2078 if (s->control_command &&
2079 s->control_command->command_next &&
2080 f == SOCKET_SUCCESS) {
2082 log_debug_unit(u->id,
2083 "%s running next command for state %s",
2084 u->id, socket_state_to_string(s->state));
2087 s->control_command = NULL;
2088 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2090 /* No further commands for this step, so let's figure
2091 * out what to do next */
2093 log_debug_unit(u->id,
2094 "%s got final SIGCHLD for state %s",
2095 u->id, socket_state_to_string(s->state));
2099 case SOCKET_START_PRE:
2100 if (f == SOCKET_SUCCESS)
2101 socket_enter_start_post(s);
2103 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2106 case SOCKET_START_POST:
2107 if (f == SOCKET_SUCCESS)
2108 socket_enter_listening(s);
2110 socket_enter_stop_pre(s, f);
2113 case SOCKET_STOP_PRE:
2114 case SOCKET_STOP_PRE_SIGTERM:
2115 case SOCKET_STOP_PRE_SIGKILL:
2116 socket_enter_stop_post(s, f);
2119 case SOCKET_STOP_POST:
2120 case SOCKET_FINAL_SIGTERM:
2121 case SOCKET_FINAL_SIGKILL:
2122 socket_enter_dead(s, f);
2126 assert_not_reached("Uh, control process died at wrong time.");
2130 /* Notify clients about changed exit status */
2131 unit_add_to_dbus_queue(u);
2134 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2135 Socket *s = SOCKET(u);
2138 assert(elapsed == 1);
2139 assert(w == &s->timer_watch);
2143 case SOCKET_START_PRE:
2144 log_warning_unit(u->id,
2145 "%s starting timed out. Terminating.", u->id);
2146 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2149 case SOCKET_START_POST:
2150 log_warning_unit(u->id,
2151 "%s starting timed out. Stopping.", u->id);
2152 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2155 case SOCKET_STOP_PRE:
2156 log_warning_unit(u->id,
2157 "%s stopping timed out. Terminating.", u->id);
2158 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2161 case SOCKET_STOP_PRE_SIGTERM:
2162 if (s->kill_context.send_sigkill) {
2163 log_warning_unit(u->id,
2164 "%s stopping timed out. Killing.", u->id);
2165 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2167 log_warning_unit(u->id,
2168 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2170 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2174 case SOCKET_STOP_PRE_SIGKILL:
2175 log_warning_unit(u->id,
2176 "%s still around after SIGKILL. Ignoring.", u->id);
2177 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2180 case SOCKET_STOP_POST:
2181 log_warning_unit(u->id,
2182 "%s stopping timed out (2). Terminating.", u->id);
2183 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2186 case SOCKET_FINAL_SIGTERM:
2187 if (s->kill_context.send_sigkill) {
2188 log_warning_unit(u->id,
2189 "%s stopping timed out (2). Killing.", u->id);
2190 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2192 log_warning_unit(u->id,
2193 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2195 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2199 case SOCKET_FINAL_SIGKILL:
2200 log_warning_unit(u->id,
2201 "%s still around after SIGKILL (2). Entering failed mode.",
2203 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2207 assert_not_reached("Timeout at wrong time.");
2211 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2220 /* Called from the service code for requesting our fds */
2223 LIST_FOREACH(port, p, s->ports)
2233 if (!(rfds = new(int, rn_fds)))
2237 LIST_FOREACH(port, p, s->ports)
2241 assert(k == rn_fds);
2249 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2252 /* The service is dead. Dang!
2254 * This is strictly for one-instance-for-all-connections
2257 if (s->state == SOCKET_RUNNING) {
2258 log_debug_unit(UNIT(s)->id,
2259 "%s got notified about service death (failed permanently: %s)",
2260 UNIT(s)->id, yes_no(failed_permanent));
2261 if (failed_permanent)
2262 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2264 socket_enter_listening(s);
2268 void socket_connection_unref(Socket *s) {
2271 /* The service is dead. Yay!
2273 * This is strictly for one-instance-per-connection
2276 assert(s->n_connections > 0);
2279 log_debug_unit(UNIT(s)->id,
2280 "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2283 static void socket_reset_failed(Unit *u) {
2284 Socket *s = SOCKET(u);
2288 if (s->state == SOCKET_FAILED)
2289 socket_set_state(s, SOCKET_DEAD);
2291 s->result = SOCKET_SUCCESS;
2294 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2295 Socket *s = SOCKET(u);
2297 Set *pid_set = NULL;
2301 if (who == KILL_MAIN) {
2302 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Socket units have no main processes");
2306 if (s->control_pid <= 0 && who == KILL_CONTROL) {
2307 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2311 if (who == KILL_CONTROL || who == KILL_ALL)
2312 if (s->control_pid > 0)
2313 if (kill(s->control_pid, signo) < 0)
2316 if (who == KILL_ALL) {
2319 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2323 /* Exclude the control pid from being killed via the cgroup */
2324 if (s->control_pid > 0) {
2325 q = set_put(pid_set, LONG_TO_PTR(s->control_pid));
2332 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
2333 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2344 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2345 [SOCKET_DEAD] = "dead",
2346 [SOCKET_START_PRE] = "start-pre",
2347 [SOCKET_START_POST] = "start-post",
2348 [SOCKET_LISTENING] = "listening",
2349 [SOCKET_RUNNING] = "running",
2350 [SOCKET_STOP_PRE] = "stop-pre",
2351 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2352 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2353 [SOCKET_STOP_POST] = "stop-post",
2354 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2355 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2356 [SOCKET_FAILED] = "failed"
2359 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2361 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2362 [SOCKET_EXEC_START_PRE] = "StartPre",
2363 [SOCKET_EXEC_START_POST] = "StartPost",
2364 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2365 [SOCKET_EXEC_STOP_POST] = "StopPost"
2368 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2370 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2371 [SOCKET_SUCCESS] = "success",
2372 [SOCKET_FAILURE_RESOURCES] = "resources",
2373 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2374 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2375 [SOCKET_FAILURE_SIGNAL] = "signal",
2376 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2377 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2380 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2382 const UnitVTable socket_vtable = {
2383 .object_size = sizeof(Socket),
2384 .exec_context_offset = offsetof(Socket, exec_context),
2391 .init = socket_init,
2392 .done = socket_done,
2393 .load = socket_load,
2395 .kill = socket_kill,
2397 .coldplug = socket_coldplug,
2399 .dump = socket_dump,
2401 .start = socket_start,
2402 .stop = socket_stop,
2404 .serialize = socket_serialize,
2405 .deserialize_item = socket_deserialize_item,
2406 .distribute_fds = socket_distribute_fds,
2408 .active_state = socket_active_state,
2409 .sub_state_to_string = socket_sub_state_to_string,
2411 .check_gc = socket_check_gc,
2413 .fd_event = socket_fd_event,
2414 .sigchld_event = socket_sigchld_event,
2415 .timer_event = socket_timer_event,
2417 .reset_failed = socket_reset_failed,
2419 .bus_interface = "org.freedesktop.systemd1.Socket",
2420 .bus_message_handler = bus_socket_message_handler,
2421 .bus_invalidating_properties = bus_socket_invalidating_properties,
2423 .status_message_formats = {
2424 /*.starting_stopping = {
2425 [0] = "Starting socket %s...",
2426 [1] = "Stopping socket %s...",
2428 .finished_start_job = {
2429 [JOB_DONE] = "Listening on %s.",
2430 [JOB_FAILED] = "Failed to listen on %s.",
2431 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2432 [JOB_TIMEOUT] = "Timed out starting %s.",
2434 .finished_stop_job = {
2435 [JOB_DONE] = "Closed %s.",
2436 [JOB_FAILED] = "Failed stopping %s.",
2437 [JOB_TIMEOUT] = "Timed out stopping %s.",