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 #include <attr/xattr.h>
35 #include "netinet/tcp.h"
37 #include "load-dropin.h"
38 #include "load-fragment.h"
41 #include "path-util.h"
42 #include "unit-name.h"
43 #include "unit-printf.h"
44 #include "dbus-socket.h"
47 #include "bus-errors.h"
49 #include "exit-status.h"
52 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
53 [SOCKET_DEAD] = UNIT_INACTIVE,
54 [SOCKET_START_PRE] = UNIT_ACTIVATING,
55 [SOCKET_START_POST] = UNIT_ACTIVATING,
56 [SOCKET_LISTENING] = UNIT_ACTIVE,
57 [SOCKET_RUNNING] = UNIT_ACTIVE,
58 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
59 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
60 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
61 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
62 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
63 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
64 [SOCKET_FAILED] = UNIT_FAILED
67 static void socket_init(Unit *u) {
68 Socket *s = SOCKET(u);
71 assert(u->load_state == UNIT_STUB);
73 s->backlog = SOMAXCONN;
74 s->timeout_usec = DEFAULT_TIMEOUT_USEC;
75 s->directory_mode = 0755;
76 s->socket_mode = 0666;
78 s->max_connections = 64;
85 exec_context_init(&s->exec_context);
86 s->exec_context.std_output = u->manager->default_std_output;
87 s->exec_context.std_error = u->manager->default_std_error;
88 kill_context_init(&s->kill_context);
90 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
93 static void socket_unwatch_control_pid(Socket *s) {
96 if (s->control_pid <= 0)
99 unit_unwatch_pid(UNIT(s), s->control_pid);
103 static void socket_done(Unit *u) {
104 Socket *s = SOCKET(u);
109 while ((p = s->ports)) {
110 LIST_REMOVE(SocketPort, port, s->ports, p);
113 unit_unwatch_fd(UNIT(s), &p->fd_watch);
114 close_nointr_nofail(p->fd);
121 exec_context_done(&s->exec_context);
122 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
123 s->control_command = NULL;
125 socket_unwatch_control_pid(s);
127 unit_ref_unset(&s->service);
129 free(s->tcp_congestion);
130 s->tcp_congestion = NULL;
132 free(s->bind_to_device);
133 s->bind_to_device = NULL;
136 free(s->smack_ip_in);
137 free(s->smack_ip_out);
139 unit_unwatch_timer(u, &s->timer_watch);
142 static int socket_instantiate_service(Socket *s) {
149 /* This fills in s->service if it isn't filled in yet. For
150 * Accept=yes sockets we create the next connection service
151 * here. For Accept=no this is mostly a NOP since the service
152 * is figured out at load time anyway. */
154 if (UNIT_DEREF(s->service))
159 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
162 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
168 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
174 #ifdef HAVE_SYSV_COMPAT
175 if (SERVICE(u)->is_sysv) {
176 log_error("Using SysV services for socket activation is not supported. Refusing.");
182 unit_ref_set(&s->service, u);
184 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
187 static bool have_non_accept_socket(Socket *s) {
195 LIST_FOREACH(port, p, s->ports) {
197 if (p->type != SOCKET_SOCKET)
200 if (!socket_address_can_accept(&p->address))
207 static int socket_verify(Socket *s) {
210 if (UNIT(s)->load_state != UNIT_LOADED)
214 log_error("%s lacks Listen setting. Refusing.", UNIT(s)->id);
218 if (s->accept && have_non_accept_socket(s)) {
219 log_error("%s configured for accepting sockets, but sockets are non-accepting. Refusing.", UNIT(s)->id);
223 if (s->accept && s->max_connections <= 0) {
224 log_error("%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
228 if (s->accept && UNIT_DEREF(s->service)) {
229 log_error("Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
233 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
234 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
241 static bool socket_needs_mount(Socket *s, const char *prefix) {
246 LIST_FOREACH(port, p, s->ports) {
248 if (p->type == SOCKET_SOCKET) {
249 if (socket_address_needs_mount(&p->address, prefix))
251 } else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL) {
252 if (path_startswith(p->path, prefix))
260 int socket_add_one_mount_link(Socket *s, Mount *m) {
266 if (UNIT(s)->load_state != UNIT_LOADED ||
267 UNIT(m)->load_state != UNIT_LOADED)
270 if (!socket_needs_mount(s, m->where))
273 r = unit_add_two_dependencies(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
280 static int socket_add_mount_links(Socket *s) {
286 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_MOUNT]) {
287 r = socket_add_one_mount_link(s, MOUNT(other));
295 static int socket_add_device_link(Socket *s) {
301 if (!s->bind_to_device)
304 if (asprintf(&t, "/sys/subsystem/net/devices/%s", s->bind_to_device) < 0)
307 r = unit_add_node_link(UNIT(s), t, false);
313 static int socket_add_default_dependencies(Socket *s) {
317 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
318 if ((r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true)) < 0)
321 if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true)) < 0)
325 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
328 static bool socket_has_exec(Socket *s) {
332 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
333 if (s->exec_command[i])
339 static int socket_load(Unit *u) {
340 Socket *s = SOCKET(u);
344 assert(u->load_state == UNIT_STUB);
346 if ((r = unit_load_fragment_and_dropin(u)) < 0)
349 /* This is a new unit? Then let's add in some extras */
350 if (u->load_state == UNIT_LOADED) {
352 if (have_non_accept_socket(s)) {
354 if (!UNIT_DEREF(s->service)) {
357 r = unit_load_related_unit(u, ".service", &x);
361 unit_ref_set(&s->service, x);
364 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
369 if ((r = socket_add_mount_links(s)) < 0)
372 if ((r = socket_add_device_link(s)) < 0)
375 if (socket_has_exec(s))
376 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
379 if ((r = unit_add_default_cgroups(u)) < 0)
382 if (UNIT(s)->default_dependencies)
383 if ((r = socket_add_default_dependencies(s)) < 0)
386 r = unit_exec_context_defaults(u, &s->exec_context);
391 return socket_verify(s);
394 static const char* listen_lookup(int family, int type) {
396 if (family == AF_NETLINK)
397 return "ListenNetlink";
399 if (type == SOCK_STREAM)
400 return "ListenStream";
401 else if (type == SOCK_DGRAM)
402 return "ListenDatagram";
403 else if (type == SOCK_SEQPACKET)
404 return "ListenSequentialPacket";
406 assert_not_reached("Unknown socket type");
410 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
413 Socket *s = SOCKET(u);
421 p2 = strappend(prefix, "\t");
422 prefix2 = p2 ? p2 : prefix;
425 "%sSocket State: %s\n"
427 "%sBindIPv6Only: %s\n"
429 "%sSocketMode: %04o\n"
430 "%sDirectoryMode: %04o\n"
433 "%sTransparent: %s\n"
435 "%sPassCredentials: %s\n"
436 "%sPassSecurity: %s\n"
437 "%sTCPCongestion: %s\n",
438 prefix, socket_state_to_string(s->state),
439 prefix, socket_result_to_string(s->result),
440 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
442 prefix, s->socket_mode,
443 prefix, s->directory_mode,
444 prefix, yes_no(s->keep_alive),
445 prefix, yes_no(s->free_bind),
446 prefix, yes_no(s->transparent),
447 prefix, yes_no(s->broadcast),
448 prefix, yes_no(s->pass_cred),
449 prefix, yes_no(s->pass_sec),
450 prefix, strna(s->tcp_congestion));
452 if (s->control_pid > 0)
454 "%sControl PID: %lu\n",
455 prefix, (unsigned long) s->control_pid);
457 if (s->bind_to_device)
459 "%sBindToDevice: %s\n",
460 prefix, s->bind_to_device);
465 "%sNConnections: %u\n"
466 "%sMaxConnections: %u\n",
467 prefix, s->n_accepted,
468 prefix, s->n_connections,
469 prefix, s->max_connections);
471 if (s->priority >= 0)
474 prefix, s->priority);
476 if (s->receive_buffer > 0)
478 "%sReceiveBuffer: %zu\n",
479 prefix, s->receive_buffer);
481 if (s->send_buffer > 0)
483 "%sSendBuffer: %zu\n",
484 prefix, s->send_buffer);
496 if (s->pipe_size > 0)
499 prefix, s->pipe_size);
506 if (s->mq_maxmsg > 0)
508 "%sMessageQueueMaxMessages: %li\n",
509 prefix, s->mq_maxmsg);
511 if (s->mq_msgsize > 0)
513 "%sMessageQueueMessageSize: %li\n",
514 prefix, s->mq_msgsize);
518 "%sSmackLabel: %s\n",
523 "%sSmackLabelIPIn: %s\n",
524 prefix, s->smack_ip_in);
528 "%sSmackLabelIPOut: %s\n",
529 prefix, s->smack_ip_out);
531 LIST_FOREACH(port, p, s->ports) {
533 if (p->type == SOCKET_SOCKET) {
538 if ((r = socket_address_print(&p->address, &k)) < 0)
543 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
545 } else if (p->type == SOCKET_SPECIAL)
546 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
547 else if (p->type == SOCKET_MQUEUE)
548 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
550 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
553 exec_context_dump(&s->exec_context, f, prefix);
554 kill_context_dump(&s->kill_context, f, prefix);
556 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
557 if (!s->exec_command[c])
560 fprintf(f, "%s-> %s:\n",
561 prefix, socket_exec_command_to_string(c));
563 exec_command_dump_list(s->exec_command[c], f, prefix2);
569 static int instance_from_socket(int fd, unsigned nr, char **instance) {
574 struct sockaddr_un un;
575 struct sockaddr_in in;
576 struct sockaddr_in6 in6;
577 struct sockaddr_storage storage;
584 if (getsockname(fd, &local.sa, &l) < 0)
588 if (getpeername(fd, &remote.sa, &l) < 0)
591 switch (local.sa.sa_family) {
595 a = ntohl(local.in.sin_addr.s_addr),
596 b = ntohl(remote.in.sin_addr.s_addr);
599 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
601 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
602 ntohs(local.in.sin_port),
603 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
604 ntohs(remote.in.sin_port)) < 0)
611 static const unsigned char ipv4_prefix[] = {
612 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
615 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
616 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
618 *a = local.in6.sin6_addr.s6_addr+12,
619 *b = remote.in6.sin6_addr.s6_addr+12;
622 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
624 a[0], a[1], a[2], a[3],
625 ntohs(local.in6.sin6_port),
626 b[0], b[1], b[2], b[3],
627 ntohs(remote.in6.sin6_port)) < 0)
630 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
635 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
636 ntohs(local.in6.sin6_port),
637 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
638 ntohs(remote.in6.sin6_port)) < 0)
649 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
655 (unsigned long) ucred.pid,
656 (unsigned long) ucred.uid) < 0)
663 assert_not_reached("Unhandled socket type.");
670 static void socket_close_fds(Socket *s) {
675 LIST_FOREACH(port, p, s->ports) {
679 unit_unwatch_fd(UNIT(s), &p->fd_watch);
680 close_nointr_nofail(p->fd);
682 /* One little note: we should never delete any sockets
683 * in the file system here! After all some other
684 * process we spawned might still have a reference of
685 * this fd and wants to continue to use it. Therefore
686 * we delete sockets in the file system before we
687 * create a new one, not after we stopped using
694 static void socket_apply_socket_options(Socket *s, int fd) {
699 int b = s->keep_alive;
700 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
701 log_warning("SO_KEEPALIVE failed: %m");
706 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
707 log_warning("SO_BROADCAST failed: %m");
712 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
713 log_warning("SO_PASSCRED failed: %m");
718 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
719 log_warning("SO_PASSSEC failed: %m");
722 if (s->priority >= 0)
723 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
724 log_warning("SO_PRIORITY failed: %m");
726 if (s->receive_buffer > 0) {
727 int value = (int) s->receive_buffer;
729 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
731 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
732 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
733 log_warning("SO_RCVBUF failed: %m");
736 if (s->send_buffer > 0) {
737 int value = (int) s->send_buffer;
738 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
739 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
740 log_warning("SO_SNDBUF failed: %m");
744 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
745 log_warning("SO_MARK failed: %m");
748 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
749 log_warning("IP_TOS failed: %m");
751 if (s->ip_ttl >= 0) {
754 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
756 if (socket_ipv6_is_supported())
757 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
760 errno = EAFNOSUPPORT;
764 log_warning("IP_TTL/IPV6_UNICAST_HOPS failed: %m");
767 if (s->tcp_congestion)
768 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
769 log_warning("TCP_CONGESTION failed: %m");
772 if (fsetxattr(fd, "security.SMACK64IPIN", s->smack_ip_in, strlen(s->smack_ip_in), 0) < 0)
773 log_error("fsetxattr(\"security.SMACK64IPIN\"): %m");
776 if (fsetxattr(fd, "security.SMACK64IPOUT", s->smack_ip_out, strlen(s->smack_ip_out), 0) < 0)
777 log_error("fsetxattr(\"security.SMACK64IPOUT\"): %m");
780 static void socket_apply_fifo_options(Socket *s, int fd) {
784 if (s->pipe_size > 0)
785 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
786 log_warning("F_SETPIPE_SZ: %m");
789 if (fsetxattr(fd, "security.SMACK64", s->smack, strlen(s->smack), 0) < 0)
790 log_error("fsetxattr(\"security.SMACK64\"): %m");
793 static int fifo_address_create(
795 mode_t directory_mode,
806 mkdir_parents_label(path, directory_mode);
808 r = label_context_set(path, S_IFIFO);
812 /* Enforce the right access mode for the fifo */
813 old_mask = umask(~ socket_mode);
815 /* Include the original umask in our mask */
816 umask(~socket_mode | old_mask);
818 r = mkfifo(path, socket_mode);
821 if (r < 0 && errno != EEXIST) {
826 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
831 label_context_clear();
833 if (fstat(fd, &st) < 0) {
838 if (!S_ISFIFO(st.st_mode) ||
839 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
840 st.st_uid != getuid() ||
841 st.st_gid != getgid()) {
851 label_context_clear();
854 close_nointr_nofail(fd);
859 static int special_address_create(
869 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
874 if (fstat(fd, &st) < 0) {
879 /* Check whether this is a /proc, /sys or /dev file or char device */
880 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
890 close_nointr_nofail(fd);
895 static int mq_address_create(
905 struct mq_attr _attr, *attr = NULL;
910 if (maxmsg > 0 && msgsize > 0) {
912 _attr.mq_flags = O_NONBLOCK;
913 _attr.mq_maxmsg = maxmsg;
914 _attr.mq_msgsize = msgsize;
918 /* Enforce the right access mode for the mq */
919 old_mask = umask(~ mq_mode);
921 /* Include the original umask in our mask */
922 umask(~mq_mode | old_mask);
924 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
932 if (fstat(fd, &st) < 0) {
937 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
938 st.st_uid != getuid() ||
939 st.st_gid != getgid()) {
950 close_nointr_nofail(fd);
955 static int socket_open_fds(Socket *s) {
959 bool know_label = false;
963 LIST_FOREACH(port, p, s->ports) {
968 if (p->type == SOCKET_SOCKET) {
972 if ((r = socket_instantiate_service(s)) < 0)
975 if (UNIT_DEREF(s->service) &&
976 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
977 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
988 if ((r = socket_address_listen(
1001 socket_apply_socket_options(s, p->fd);
1003 } else if (p->type == SOCKET_SPECIAL) {
1005 if ((r = special_address_create(
1010 } else if (p->type == SOCKET_FIFO) {
1012 if ((r = fifo_address_create(
1019 socket_apply_fifo_options(s, p->fd);
1020 } else if (p->type == SOCKET_MQUEUE) {
1022 if ((r = mq_address_create(
1030 assert_not_reached("Unknown port type");
1037 socket_close_fds(s);
1042 static void socket_unwatch_fds(Socket *s) {
1047 LIST_FOREACH(port, p, s->ports) {
1051 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1055 static int socket_watch_fds(Socket *s) {
1061 LIST_FOREACH(port, p, s->ports) {
1065 p->fd_watch.socket_accept =
1067 p->type == SOCKET_SOCKET &&
1068 socket_address_can_accept(&p->address);
1070 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1077 socket_unwatch_fds(s);
1081 static void socket_set_state(Socket *s, SocketState state) {
1082 SocketState old_state;
1085 old_state = s->state;
1088 if (state != SOCKET_START_PRE &&
1089 state != SOCKET_START_POST &&
1090 state != SOCKET_STOP_PRE &&
1091 state != SOCKET_STOP_PRE_SIGTERM &&
1092 state != SOCKET_STOP_PRE_SIGKILL &&
1093 state != SOCKET_STOP_POST &&
1094 state != SOCKET_FINAL_SIGTERM &&
1095 state != SOCKET_FINAL_SIGKILL) {
1096 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1097 socket_unwatch_control_pid(s);
1098 s->control_command = NULL;
1099 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1102 if (state != SOCKET_LISTENING)
1103 socket_unwatch_fds(s);
1105 if (state != SOCKET_START_POST &&
1106 state != SOCKET_LISTENING &&
1107 state != SOCKET_RUNNING &&
1108 state != SOCKET_STOP_PRE &&
1109 state != SOCKET_STOP_PRE_SIGTERM &&
1110 state != SOCKET_STOP_PRE_SIGKILL)
1111 socket_close_fds(s);
1113 if (state != old_state)
1114 log_debug("%s changed %s -> %s",
1116 socket_state_to_string(old_state),
1117 socket_state_to_string(state));
1119 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1122 static int socket_coldplug(Unit *u) {
1123 Socket *s = SOCKET(u);
1127 assert(s->state == SOCKET_DEAD);
1129 if (s->deserialized_state != s->state) {
1131 if (s->deserialized_state == SOCKET_START_PRE ||
1132 s->deserialized_state == SOCKET_START_POST ||
1133 s->deserialized_state == SOCKET_STOP_PRE ||
1134 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1135 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1136 s->deserialized_state == SOCKET_STOP_POST ||
1137 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1138 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1140 if (s->control_pid <= 0)
1143 if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
1146 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1150 if (s->deserialized_state == SOCKET_START_POST ||
1151 s->deserialized_state == SOCKET_LISTENING ||
1152 s->deserialized_state == SOCKET_RUNNING ||
1153 s->deserialized_state == SOCKET_STOP_PRE ||
1154 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1155 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1156 if ((r = socket_open_fds(s)) < 0)
1159 if (s->deserialized_state == SOCKET_LISTENING)
1160 if ((r = socket_watch_fds(s)) < 0)
1163 socket_set_state(s, s->deserialized_state);
1169 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1178 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1181 if (!(argv = unit_full_printf_strv(UNIT(s), c->argv))) {
1190 UNIT(s)->manager->environment,
1194 UNIT(s)->manager->confirm_spawn,
1195 UNIT(s)->cgroup_bondings,
1196 UNIT(s)->cgroup_attributes,
1206 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1207 /* FIXME: we need to do something here */
1215 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1220 static void socket_enter_dead(Socket *s, SocketResult f) {
1223 if (f != SOCKET_SUCCESS)
1226 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1229 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1231 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1235 if (f != SOCKET_SUCCESS)
1238 socket_unwatch_control_pid(s);
1240 s->control_command_id = SOCKET_EXEC_STOP_POST;
1242 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1243 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1246 socket_set_state(s, SOCKET_STOP_POST);
1248 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1253 log_warning("%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
1254 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1257 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1259 Set *pid_set = NULL;
1260 bool wait_for_exit = false;
1264 if (f != SOCKET_SUCCESS)
1267 if (s->kill_context.kill_mode != KILL_NONE) {
1268 int sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_FINAL_SIGTERM) ? s->kill_context.kill_signal : SIGKILL;
1270 if (s->control_pid > 0) {
1271 if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
1273 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
1275 wait_for_exit = true;
1278 if (s->kill_context.kill_mode == KILL_CONTROL_GROUP) {
1280 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
1285 /* Exclude the control pid from being killed via the cgroup */
1286 if (s->control_pid > 0)
1287 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
1290 r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
1292 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
1293 log_warning("Failed to kill control group: %s", strerror(-r));
1295 wait_for_exit = true;
1302 if (wait_for_exit) {
1303 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1306 socket_set_state(s, state);
1307 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1308 socket_enter_stop_post(s, SOCKET_SUCCESS);
1310 socket_enter_dead(s, SOCKET_SUCCESS);
1315 log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1317 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1318 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1320 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1326 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1330 if (f != SOCKET_SUCCESS)
1333 socket_unwatch_control_pid(s);
1335 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1337 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1338 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1341 socket_set_state(s, SOCKET_STOP_PRE);
1343 socket_enter_stop_post(s, SOCKET_SUCCESS);
1348 log_warning("%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1349 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1352 static void socket_enter_listening(Socket *s) {
1356 r = socket_watch_fds(s);
1358 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1362 socket_set_state(s, SOCKET_LISTENING);
1366 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1369 static void socket_enter_start_post(Socket *s) {
1373 r = socket_open_fds(s);
1375 log_warning("%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1379 socket_unwatch_control_pid(s);
1381 s->control_command_id = SOCKET_EXEC_START_POST;
1383 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1384 r = socket_spawn(s, s->control_command, &s->control_pid);
1386 log_warning("%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1390 socket_set_state(s, SOCKET_START_POST);
1392 socket_enter_listening(s);
1397 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1400 static void socket_enter_start_pre(Socket *s) {
1404 socket_unwatch_control_pid(s);
1406 s->control_command_id = SOCKET_EXEC_START_PRE;
1408 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1409 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1412 socket_set_state(s, SOCKET_START_PRE);
1414 socket_enter_start_post(s);
1419 log_warning("%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1420 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1423 static void socket_enter_running(Socket *s, int cfd) {
1428 dbus_error_init(&error);
1430 /* We don't take connections anymore if we are supposed to
1431 * shut down anyway */
1432 if (unit_pending_inactive(UNIT(s))) {
1433 log_debug("Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1436 close_nointr_nofail(cfd);
1438 /* Flush all sockets by closing and reopening them */
1439 socket_close_fds(s);
1441 r = socket_watch_fds(s);
1443 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1444 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1454 bool pending = false;
1456 /* If there's already a start pending don't bother to
1458 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1459 if (unit_pending_active(u)) {
1465 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1470 socket_set_state(s, SOCKET_RUNNING);
1472 char *prefix, *instance = NULL, *name;
1475 if (s->n_connections >= s->max_connections) {
1476 log_warning("Too many incoming connections (%u)", s->n_connections);
1477 close_nointr_nofail(cfd);
1481 r = socket_instantiate_service(s);
1485 r = instance_from_socket(cfd, s->n_accepted, &instance);
1490 /* ENOTCONN is legitimate if TCP RST was received.
1491 * This connection is over, but the socket unit lives on. */
1492 close_nointr_nofail(cfd);
1496 prefix = unit_name_to_prefix(UNIT(s)->id);
1503 name = unit_name_build(prefix, instance, ".service");
1512 r = unit_add_name(UNIT_DEREF(s->service), name);
1518 service = SERVICE(UNIT_DEREF(s->service));
1519 unit_ref_unset(&s->service);
1522 UNIT(service)->no_gc = false;
1524 unit_choose_id(UNIT(service), name);
1527 r = service_set_socket_fd(service, cfd, s);
1532 s->n_connections ++;
1534 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1538 /* Notify clients about changed counters */
1539 unit_add_to_dbus_queue(UNIT(s));
1545 log_warning("%s failed to queue socket startup job: %s", UNIT(s)->id, bus_error(&error, r));
1546 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1549 close_nointr_nofail(cfd);
1551 dbus_error_free(&error);
1554 static void socket_run_next(Socket *s) {
1558 assert(s->control_command);
1559 assert(s->control_command->command_next);
1561 socket_unwatch_control_pid(s);
1563 s->control_command = s->control_command->command_next;
1565 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1571 log_warning("%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1573 if (s->state == SOCKET_START_POST)
1574 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1575 else if (s->state == SOCKET_STOP_POST)
1576 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1578 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1581 static int socket_start(Unit *u) {
1582 Socket *s = SOCKET(u);
1586 /* We cannot fulfill this request right now, try again later
1588 if (s->state == SOCKET_STOP_PRE ||
1589 s->state == SOCKET_STOP_PRE_SIGKILL ||
1590 s->state == SOCKET_STOP_PRE_SIGTERM ||
1591 s->state == SOCKET_STOP_POST ||
1592 s->state == SOCKET_FINAL_SIGTERM ||
1593 s->state == SOCKET_FINAL_SIGKILL)
1596 if (s->state == SOCKET_START_PRE ||
1597 s->state == SOCKET_START_POST)
1600 /* Cannot run this without the service being around */
1601 if (UNIT_DEREF(s->service)) {
1604 service = SERVICE(UNIT_DEREF(s->service));
1606 if (UNIT(service)->load_state != UNIT_LOADED) {
1607 log_error("Socket service %s not loaded, refusing.", UNIT(service)->id);
1611 /* If the service is already active we cannot start the
1613 if (service->state != SERVICE_DEAD &&
1614 service->state != SERVICE_FAILED &&
1615 service->state != SERVICE_AUTO_RESTART) {
1616 log_error("Socket service %s already active, refusing.", UNIT(service)->id);
1620 #ifdef HAVE_SYSV_COMPAT
1621 if (service->is_sysv) {
1622 log_error("Using SysV services for socket activation is not supported. Refusing.");
1628 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1630 s->result = SOCKET_SUCCESS;
1631 socket_enter_start_pre(s);
1635 static int socket_stop(Unit *u) {
1636 Socket *s = SOCKET(u);
1641 if (s->state == SOCKET_STOP_PRE ||
1642 s->state == SOCKET_STOP_PRE_SIGTERM ||
1643 s->state == SOCKET_STOP_PRE_SIGKILL ||
1644 s->state == SOCKET_STOP_POST ||
1645 s->state == SOCKET_FINAL_SIGTERM ||
1646 s->state == SOCKET_FINAL_SIGKILL)
1649 /* If there's already something running we go directly into
1651 if (s->state == SOCKET_START_PRE ||
1652 s->state == SOCKET_START_POST) {
1653 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1657 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1659 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1663 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1664 Socket *s = SOCKET(u);
1672 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1673 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1674 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1676 if (s->control_pid > 0)
1677 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1679 if (s->control_command_id >= 0)
1680 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1682 LIST_FOREACH(port, p, s->ports) {
1688 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1691 if (p->type == SOCKET_SOCKET) {
1694 if ((r = socket_address_print(&p->address, &t)) < 0)
1697 if (socket_address_family(&p->address) == AF_NETLINK)
1698 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1700 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1702 } else if (p->type == SOCKET_SPECIAL)
1703 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1705 assert(p->type == SOCKET_FIFO);
1706 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1713 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1714 Socket *s = SOCKET(u);
1721 if (streq(key, "state")) {
1724 if ((state = socket_state_from_string(value)) < 0)
1725 log_debug("Failed to parse state value %s", value);
1727 s->deserialized_state = state;
1728 } else if (streq(key, "result")) {
1731 f = socket_result_from_string(value);
1733 log_debug("Failed to parse result value %s", value);
1734 else if (f != SOCKET_SUCCESS)
1737 } else if (streq(key, "n-accepted")) {
1740 if (safe_atou(value, &k) < 0)
1741 log_debug("Failed to parse n-accepted value %s", value);
1744 } else if (streq(key, "control-pid")) {
1747 if (parse_pid(value, &pid) < 0)
1748 log_debug("Failed to parse control-pid value %s", value);
1750 s->control_pid = pid;
1751 } else if (streq(key, "control-command")) {
1752 SocketExecCommand id;
1754 if ((id = socket_exec_command_from_string(value)) < 0)
1755 log_debug("Failed to parse exec-command value %s", value);
1757 s->control_command_id = id;
1758 s->control_command = s->exec_command[id];
1760 } else if (streq(key, "fifo")) {
1764 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1765 log_debug("Failed to parse fifo value %s", value);
1768 LIST_FOREACH(port, p, s->ports)
1769 if (p->type == SOCKET_FIFO &&
1770 streq_ptr(p->path, value+skip))
1775 close_nointr_nofail(p->fd);
1776 p->fd = fdset_remove(fds, fd);
1780 } else if (streq(key, "special")) {
1784 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1785 log_debug("Failed to parse special value %s", value);
1788 LIST_FOREACH(port, p, s->ports)
1789 if (p->type == SOCKET_SPECIAL &&
1790 streq_ptr(p->path, value+skip))
1795 close_nointr_nofail(p->fd);
1796 p->fd = fdset_remove(fds, fd);
1800 } else if (streq(key, "socket")) {
1801 int fd, type, skip = 0;
1804 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1805 log_debug("Failed to parse socket value %s", value);
1808 LIST_FOREACH(port, p, s->ports)
1809 if (socket_address_is(&p->address, value+skip, type))
1814 close_nointr_nofail(p->fd);
1815 p->fd = fdset_remove(fds, fd);
1819 } else if (streq(key, "netlink")) {
1823 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1824 log_debug("Failed to parse socket value %s", value);
1827 LIST_FOREACH(port, p, s->ports)
1828 if (socket_address_is_netlink(&p->address, value+skip))
1833 close_nointr_nofail(p->fd);
1834 p->fd = fdset_remove(fds, fd);
1839 log_debug("Unknown serialization key '%s'", key);
1844 static UnitActiveState socket_active_state(Unit *u) {
1847 return state_translation_table[SOCKET(u)->state];
1850 static const char *socket_sub_state_to_string(Unit *u) {
1853 return socket_state_to_string(SOCKET(u)->state);
1856 static bool socket_check_gc(Unit *u) {
1857 Socket *s = SOCKET(u);
1861 return s->n_connections > 0;
1864 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1865 Socket *s = SOCKET(u);
1871 if (s->state != SOCKET_LISTENING)
1874 log_debug("Incoming traffic on %s", u->id);
1876 if (events != EPOLLIN) {
1878 if (events & EPOLLHUP)
1879 log_error("%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.", u->id);
1881 log_error("%s: Got unexpected poll event (0x%x) on socket.", u->id, events);
1886 if (w->socket_accept) {
1889 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
1895 log_error("Failed to accept socket: %m");
1902 socket_apply_socket_options(s, cfd);
1905 socket_enter_running(s, cfd);
1909 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1912 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1913 Socket *s = SOCKET(u);
1919 if (pid != s->control_pid)
1924 if (is_clean_exit(code, status, NULL))
1926 else if (code == CLD_EXITED)
1927 f = SOCKET_FAILURE_EXIT_CODE;
1928 else if (code == CLD_KILLED)
1929 f = SOCKET_FAILURE_SIGNAL;
1930 else if (code == CLD_DUMPED)
1931 f = SOCKET_FAILURE_CORE_DUMP;
1933 assert_not_reached("Unknown code");
1935 if (s->control_command) {
1936 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
1938 if (s->control_command->ignore)
1942 log_full(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1943 "%s control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1945 if (f != SOCKET_SUCCESS)
1948 if (s->control_command &&
1949 s->control_command->command_next &&
1950 f == SOCKET_SUCCESS) {
1952 log_debug("%s running next command for state %s", u->id, socket_state_to_string(s->state));
1955 s->control_command = NULL;
1956 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1958 /* No further commands for this step, so let's figure
1959 * out what to do next */
1961 log_debug("%s got final SIGCHLD for state %s", u->id, socket_state_to_string(s->state));
1965 case SOCKET_START_PRE:
1966 if (f == SOCKET_SUCCESS)
1967 socket_enter_start_post(s);
1969 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
1972 case SOCKET_START_POST:
1973 if (f == SOCKET_SUCCESS)
1974 socket_enter_listening(s);
1976 socket_enter_stop_pre(s, f);
1979 case SOCKET_STOP_PRE:
1980 case SOCKET_STOP_PRE_SIGTERM:
1981 case SOCKET_STOP_PRE_SIGKILL:
1982 socket_enter_stop_post(s, f);
1985 case SOCKET_STOP_POST:
1986 case SOCKET_FINAL_SIGTERM:
1987 case SOCKET_FINAL_SIGKILL:
1988 socket_enter_dead(s, f);
1992 assert_not_reached("Uh, control process died at wrong time.");
1996 /* Notify clients about changed exit status */
1997 unit_add_to_dbus_queue(u);
2000 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2001 Socket *s = SOCKET(u);
2004 assert(elapsed == 1);
2005 assert(w == &s->timer_watch);
2009 case SOCKET_START_PRE:
2010 log_warning("%s starting timed out. Terminating.", u->id);
2011 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2014 case SOCKET_START_POST:
2015 log_warning("%s starting timed out. Stopping.", u->id);
2016 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2019 case SOCKET_STOP_PRE:
2020 log_warning("%s stopping timed out. Terminating.", u->id);
2021 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2024 case SOCKET_STOP_PRE_SIGTERM:
2025 if (s->kill_context.send_sigkill) {
2026 log_warning("%s stopping timed out. Killing.", u->id);
2027 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2029 log_warning("%s stopping timed out. Skipping SIGKILL. Ignoring.", u->id);
2030 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2034 case SOCKET_STOP_PRE_SIGKILL:
2035 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
2036 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2039 case SOCKET_STOP_POST:
2040 log_warning("%s stopping timed out (2). Terminating.", u->id);
2041 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2044 case SOCKET_FINAL_SIGTERM:
2045 if (s->kill_context.send_sigkill) {
2046 log_warning("%s stopping timed out (2). Killing.", u->id);
2047 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2049 log_warning("%s stopping timed out (2). Skipping SIGKILL. Ignoring.", u->id);
2050 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2054 case SOCKET_FINAL_SIGKILL:
2055 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
2056 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2060 assert_not_reached("Timeout at wrong time.");
2064 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2073 /* Called from the service code for requesting our fds */
2076 LIST_FOREACH(port, p, s->ports)
2086 if (!(rfds = new(int, rn_fds)))
2090 LIST_FOREACH(port, p, s->ports)
2094 assert(k == rn_fds);
2102 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2105 /* The service is dead. Dang!
2107 * This is strictly for one-instance-for-all-connections
2110 if (s->state == SOCKET_RUNNING) {
2111 log_debug("%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2112 if (failed_permanent)
2113 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2115 socket_enter_listening(s);
2119 void socket_connection_unref(Socket *s) {
2122 /* The service is dead. Yay!
2124 * This is strictly for one-instance-per-connection
2127 assert(s->n_connections > 0);
2130 log_debug("%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2133 static void socket_reset_failed(Unit *u) {
2134 Socket *s = SOCKET(u);
2138 if (s->state == SOCKET_FAILED)
2139 socket_set_state(s, SOCKET_DEAD);
2141 s->result = SOCKET_SUCCESS;
2144 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2145 Socket *s = SOCKET(u);
2147 Set *pid_set = NULL;
2151 if (who == KILL_MAIN) {
2152 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Socket units have no main processes");
2156 if (s->control_pid <= 0 && who == KILL_CONTROL) {
2157 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2161 if (who == KILL_CONTROL || who == KILL_ALL)
2162 if (s->control_pid > 0)
2163 if (kill(s->control_pid, signo) < 0)
2166 if (who == KILL_ALL) {
2169 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2173 /* Exclude the control pid from being killed via the cgroup */
2174 if (s->control_pid > 0) {
2175 q = set_put(pid_set, LONG_TO_PTR(s->control_pid));
2182 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
2183 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2194 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2195 [SOCKET_DEAD] = "dead",
2196 [SOCKET_START_PRE] = "start-pre",
2197 [SOCKET_START_POST] = "start-post",
2198 [SOCKET_LISTENING] = "listening",
2199 [SOCKET_RUNNING] = "running",
2200 [SOCKET_STOP_PRE] = "stop-pre",
2201 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2202 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2203 [SOCKET_STOP_POST] = "stop-post",
2204 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2205 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2206 [SOCKET_FAILED] = "failed"
2209 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2211 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2212 [SOCKET_EXEC_START_PRE] = "StartPre",
2213 [SOCKET_EXEC_START_POST] = "StartPost",
2214 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2215 [SOCKET_EXEC_STOP_POST] = "StopPost"
2218 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2220 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2221 [SOCKET_SUCCESS] = "success",
2222 [SOCKET_FAILURE_RESOURCES] = "resources",
2223 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2224 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2225 [SOCKET_FAILURE_SIGNAL] = "signal",
2226 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2227 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2230 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2232 const UnitVTable socket_vtable = {
2233 .object_size = sizeof(Socket),
2234 .exec_context_offset = offsetof(Socket, exec_context),
2241 .init = socket_init,
2242 .done = socket_done,
2243 .load = socket_load,
2245 .kill = socket_kill,
2247 .coldplug = socket_coldplug,
2249 .dump = socket_dump,
2251 .start = socket_start,
2252 .stop = socket_stop,
2254 .serialize = socket_serialize,
2255 .deserialize_item = socket_deserialize_item,
2257 .active_state = socket_active_state,
2258 .sub_state_to_string = socket_sub_state_to_string,
2260 .check_gc = socket_check_gc,
2262 .fd_event = socket_fd_event,
2263 .sigchld_event = socket_sigchld_event,
2264 .timer_event = socket_timer_event,
2266 .reset_failed = socket_reset_failed,
2268 .bus_interface = "org.freedesktop.systemd1.Socket",
2269 .bus_message_handler = bus_socket_message_handler,
2270 .bus_invalidating_properties = bus_socket_invalidating_properties,
2272 .status_message_formats = {
2273 /*.starting_stopping = {
2274 [0] = "Starting socket %s...",
2275 [1] = "Stopping socket %s...",
2277 .finished_start_job = {
2278 [JOB_DONE] = "Listening on %s.",
2279 [JOB_FAILED] = "Failed to listen on %s.",
2280 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2281 [JOB_TIMEOUT] = "Timed out starting %s.",
2283 .finished_stop_job = {
2284 [JOB_DONE] = "Closed %s.",
2285 [JOB_FAILED] = "Failed stopping %s.",
2286 [JOB_TIMEOUT] = "Timed out stopping %s.",