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>
34 #include "netinet/tcp.h"
36 #include "load-dropin.h"
37 #include "load-fragment.h"
40 #include "path-util.h"
41 #include "unit-name.h"
42 #include "dbus-socket.h"
45 #include "bus-errors.h"
47 #include "exit-status.h"
50 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
51 [SOCKET_DEAD] = UNIT_INACTIVE,
52 [SOCKET_START_PRE] = UNIT_ACTIVATING,
53 [SOCKET_START_POST] = UNIT_ACTIVATING,
54 [SOCKET_LISTENING] = UNIT_ACTIVE,
55 [SOCKET_RUNNING] = UNIT_ACTIVE,
56 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
57 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
58 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
59 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
60 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
61 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
62 [SOCKET_FAILED] = UNIT_FAILED
65 static void socket_init(Unit *u) {
66 Socket *s = SOCKET(u);
69 assert(u->load_state == UNIT_STUB);
71 s->backlog = SOMAXCONN;
72 s->timeout_usec = DEFAULT_TIMEOUT_USEC;
73 s->directory_mode = 0755;
74 s->socket_mode = 0666;
76 s->max_connections = 64;
83 exec_context_init(&s->exec_context);
84 s->exec_context.std_output = u->manager->default_std_output;
85 s->exec_context.std_error = u->manager->default_std_error;
87 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
90 static void socket_unwatch_control_pid(Socket *s) {
93 if (s->control_pid <= 0)
96 unit_unwatch_pid(UNIT(s), s->control_pid);
100 static void socket_done(Unit *u) {
101 Socket *s = SOCKET(u);
106 while ((p = s->ports)) {
107 LIST_REMOVE(SocketPort, port, s->ports, p);
110 unit_unwatch_fd(UNIT(s), &p->fd_watch);
111 close_nointr_nofail(p->fd);
118 exec_context_done(&s->exec_context);
119 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
120 s->control_command = NULL;
122 socket_unwatch_control_pid(s);
124 unit_ref_unset(&s->service);
126 free(s->tcp_congestion);
127 s->tcp_congestion = NULL;
129 free(s->bind_to_device);
130 s->bind_to_device = NULL;
132 unit_unwatch_timer(u, &s->timer_watch);
135 static int socket_instantiate_service(Socket *s) {
142 /* This fills in s->service if it isn't filled in yet. For
143 * Accept=yes sockets we create the next connection service
144 * here. For Accept=no this is mostly a NOP since the service
145 * is figured out at load time anyway. */
147 if (UNIT_DEREF(s->service))
152 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
155 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
161 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
167 #ifdef HAVE_SYSV_COMPAT
168 if (SERVICE(u)->is_sysv) {
169 log_error("Using SysV services for socket activation is not supported. Refusing.");
175 unit_ref_set(&s->service, u);
177 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
180 static bool have_non_accept_socket(Socket *s) {
188 LIST_FOREACH(port, p, s->ports) {
190 if (p->type != SOCKET_SOCKET)
193 if (!socket_address_can_accept(&p->address))
200 static int socket_verify(Socket *s) {
203 if (UNIT(s)->load_state != UNIT_LOADED)
207 log_error("%s lacks Listen setting. Refusing.", UNIT(s)->id);
211 if (s->accept && have_non_accept_socket(s)) {
212 log_error("%s configured for accepting sockets, but sockets are non-accepting. Refusing.", UNIT(s)->id);
216 if (s->accept && s->max_connections <= 0) {
217 log_error("%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
221 if (s->accept && UNIT_DEREF(s->service)) {
222 log_error("Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
226 if (s->exec_context.pam_name && s->exec_context.kill_mode != KILL_CONTROL_GROUP) {
227 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
234 static bool socket_needs_mount(Socket *s, const char *prefix) {
239 LIST_FOREACH(port, p, s->ports) {
241 if (p->type == SOCKET_SOCKET) {
242 if (socket_address_needs_mount(&p->address, prefix))
244 } else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL) {
245 if (path_startswith(p->path, prefix))
253 int socket_add_one_mount_link(Socket *s, Mount *m) {
259 if (UNIT(s)->load_state != UNIT_LOADED ||
260 UNIT(m)->load_state != UNIT_LOADED)
263 if (!socket_needs_mount(s, m->where))
266 if ((r = unit_add_two_dependencies(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true)) < 0)
272 static int socket_add_mount_links(Socket *s) {
278 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_MOUNT])
279 if ((r = socket_add_one_mount_link(s, MOUNT(other))) < 0)
285 static int socket_add_device_link(Socket *s) {
291 if (!s->bind_to_device)
294 if (asprintf(&t, "/sys/subsystem/net/devices/%s", s->bind_to_device) < 0)
297 r = unit_add_node_link(UNIT(s), t, false);
303 static int socket_add_default_dependencies(Socket *s) {
307 if (UNIT(s)->manager->running_as == MANAGER_SYSTEM) {
308 if ((r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true)) < 0)
311 if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true)) < 0)
315 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
318 static bool socket_has_exec(Socket *s) {
322 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
323 if (s->exec_command[i])
329 static int socket_load(Unit *u) {
330 Socket *s = SOCKET(u);
334 assert(u->load_state == UNIT_STUB);
336 if ((r = unit_load_fragment_and_dropin(u)) < 0)
339 /* This is a new unit? Then let's add in some extras */
340 if (u->load_state == UNIT_LOADED) {
342 if (have_non_accept_socket(s)) {
344 if (!UNIT_DEREF(s->service)) {
347 r = unit_load_related_unit(u, ".service", &x);
351 unit_ref_set(&s->service, x);
354 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
359 if ((r = socket_add_mount_links(s)) < 0)
362 if ((r = socket_add_device_link(s)) < 0)
365 if (socket_has_exec(s))
366 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
369 if ((r = unit_add_default_cgroups(u)) < 0)
372 if (UNIT(s)->default_dependencies)
373 if ((r = socket_add_default_dependencies(s)) < 0)
376 r = unit_patch_working_directory(UNIT(s), &s->exec_context);
381 return socket_verify(s);
384 static const char* listen_lookup(int family, int type) {
386 if (family == AF_NETLINK)
387 return "ListenNetlink";
389 if (type == SOCK_STREAM)
390 return "ListenStream";
391 else if (type == SOCK_DGRAM)
392 return "ListenDatagram";
393 else if (type == SOCK_SEQPACKET)
394 return "ListenSequentialPacket";
396 assert_not_reached("Unknown socket type");
400 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
403 Socket *s = SOCKET(u);
411 p2 = strappend(prefix, "\t");
412 prefix2 = p2 ? p2 : prefix;
415 "%sSocket State: %s\n"
417 "%sBindIPv6Only: %s\n"
419 "%sSocketMode: %04o\n"
420 "%sDirectoryMode: %04o\n"
423 "%sTransparent: %s\n"
425 "%sPassCredentials: %s\n"
426 "%sPassSecurity: %s\n"
427 "%sTCPCongestion: %s\n",
428 prefix, socket_state_to_string(s->state),
429 prefix, socket_result_to_string(s->result),
430 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
432 prefix, s->socket_mode,
433 prefix, s->directory_mode,
434 prefix, yes_no(s->keep_alive),
435 prefix, yes_no(s->free_bind),
436 prefix, yes_no(s->transparent),
437 prefix, yes_no(s->broadcast),
438 prefix, yes_no(s->pass_cred),
439 prefix, yes_no(s->pass_sec),
440 prefix, strna(s->tcp_congestion));
442 if (s->control_pid > 0)
444 "%sControl PID: %lu\n",
445 prefix, (unsigned long) s->control_pid);
447 if (s->bind_to_device)
449 "%sBindToDevice: %s\n",
450 prefix, s->bind_to_device);
455 "%sNConnections: %u\n"
456 "%sMaxConnections: %u\n",
457 prefix, s->n_accepted,
458 prefix, s->n_connections,
459 prefix, s->max_connections);
461 if (s->priority >= 0)
464 prefix, s->priority);
466 if (s->receive_buffer > 0)
468 "%sReceiveBuffer: %zu\n",
469 prefix, s->receive_buffer);
471 if (s->send_buffer > 0)
473 "%sSendBuffer: %zu\n",
474 prefix, s->send_buffer);
486 if (s->pipe_size > 0)
489 prefix, s->pipe_size);
496 if (s->mq_maxmsg > 0)
498 "%sMessageQueueMaxMessages: %li\n",
499 prefix, s->mq_maxmsg);
501 if (s->mq_msgsize > 0)
503 "%sMessageQueueMessageSize: %li\n",
504 prefix, s->mq_msgsize);
506 LIST_FOREACH(port, p, s->ports) {
508 if (p->type == SOCKET_SOCKET) {
513 if ((r = socket_address_print(&p->address, &k)) < 0)
518 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
520 } else if (p->type == SOCKET_SPECIAL)
521 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
522 else if (p->type == SOCKET_MQUEUE)
523 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
525 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
528 exec_context_dump(&s->exec_context, f, prefix);
530 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
531 if (!s->exec_command[c])
534 fprintf(f, "%s-> %s:\n",
535 prefix, socket_exec_command_to_string(c));
537 exec_command_dump_list(s->exec_command[c], f, prefix2);
543 static int instance_from_socket(int fd, unsigned nr, char **instance) {
548 struct sockaddr_un un;
549 struct sockaddr_in in;
550 struct sockaddr_in6 in6;
551 struct sockaddr_storage storage;
558 if (getsockname(fd, &local.sa, &l) < 0)
562 if (getpeername(fd, &remote.sa, &l) < 0)
565 switch (local.sa.sa_family) {
569 a = ntohl(local.in.sin_addr.s_addr),
570 b = ntohl(remote.in.sin_addr.s_addr);
573 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
575 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
576 ntohs(local.in.sin_port),
577 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
578 ntohs(remote.in.sin_port)) < 0)
585 static const char ipv4_prefix[] = {
586 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
589 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
590 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
592 *a = local.in6.sin6_addr.s6_addr+12,
593 *b = remote.in6.sin6_addr.s6_addr+12;
596 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
598 a[0], a[1], a[2], a[3],
599 ntohs(local.in6.sin6_port),
600 b[0], b[1], b[2], b[3],
601 ntohs(remote.in6.sin6_port)) < 0)
604 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
609 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
610 ntohs(local.in6.sin6_port),
611 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
612 ntohs(remote.in6.sin6_port)) < 0)
623 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
629 (unsigned long) ucred.pid,
630 (unsigned long) ucred.uid) < 0)
637 assert_not_reached("Unhandled socket type.");
644 static void socket_close_fds(Socket *s) {
649 LIST_FOREACH(port, p, s->ports) {
653 unit_unwatch_fd(UNIT(s), &p->fd_watch);
654 close_nointr_nofail(p->fd);
656 /* One little note: we should never delete any sockets
657 * in the file system here! After all some other
658 * process we spawned might still have a reference of
659 * this fd and wants to continue to use it. Therefore
660 * we delete sockets in the file system before we
661 * create a new one, not after we stopped using
668 static void socket_apply_socket_options(Socket *s, int fd) {
673 int b = s->keep_alive;
674 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
675 log_warning("SO_KEEPALIVE failed: %m");
680 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
681 log_warning("SO_BROADCAST failed: %m");
686 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
687 log_warning("SO_PASSCRED failed: %m");
692 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
693 log_warning("SO_PASSSEC failed: %m");
696 if (s->priority >= 0)
697 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
698 log_warning("SO_PRIORITY failed: %m");
700 if (s->receive_buffer > 0) {
701 int value = (int) s->receive_buffer;
703 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
705 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
706 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
707 log_warning("SO_RCVBUF failed: %m");
710 if (s->send_buffer > 0) {
711 int value = (int) s->send_buffer;
712 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
713 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
714 log_warning("SO_SNDBUF failed: %m");
718 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
719 log_warning("SO_MARK failed: %m");
722 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
723 log_warning("IP_TOS failed: %m");
725 if (s->ip_ttl >= 0) {
728 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
730 if (socket_ipv6_is_supported())
731 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
734 errno = EAFNOSUPPORT;
738 log_warning("IP_TTL/IPV6_UNICAST_HOPS failed: %m");
741 if (s->tcp_congestion)
742 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
743 log_warning("TCP_CONGESTION failed: %m");
746 static void socket_apply_fifo_options(Socket *s, int fd) {
750 if (s->pipe_size > 0)
751 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
752 log_warning("F_SETPIPE_SZ: %m");
755 static int fifo_address_create(
757 mode_t directory_mode,
768 mkdir_parents_label(path, directory_mode);
770 r = label_context_set(path, S_IFIFO);
774 /* Enforce the right access mode for the fifo */
775 old_mask = umask(~ socket_mode);
777 /* Include the original umask in our mask */
778 umask(~socket_mode | old_mask);
780 r = mkfifo(path, socket_mode);
783 if (r < 0 && errno != EEXIST) {
788 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
793 label_context_clear();
795 if (fstat(fd, &st) < 0) {
800 if (!S_ISFIFO(st.st_mode) ||
801 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
802 st.st_uid != getuid() ||
803 st.st_gid != getgid()) {
813 label_context_clear();
816 close_nointr_nofail(fd);
821 static int special_address_create(
831 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
836 if (fstat(fd, &st) < 0) {
841 /* Check whether this is a /proc, /sys or /dev file or char device */
842 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
852 close_nointr_nofail(fd);
857 static int mq_address_create(
867 struct mq_attr _attr, *attr = NULL;
872 if (maxmsg > 0 && msgsize > 0) {
874 _attr.mq_flags = O_NONBLOCK;
875 _attr.mq_maxmsg = maxmsg;
876 _attr.mq_msgsize = msgsize;
880 /* Enforce the right access mode for the mq */
881 old_mask = umask(~ mq_mode);
883 /* Include the original umask in our mask */
884 umask(~mq_mode | old_mask);
886 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
894 if (fstat(fd, &st) < 0) {
899 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
900 st.st_uid != getuid() ||
901 st.st_gid != getgid()) {
912 close_nointr_nofail(fd);
917 static int socket_open_fds(Socket *s) {
921 bool know_label = false;
925 LIST_FOREACH(port, p, s->ports) {
930 if (p->type == SOCKET_SOCKET) {
934 if ((r = socket_instantiate_service(s)) < 0)
937 if (UNIT_DEREF(s->service) &&
938 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
939 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
950 if ((r = socket_address_listen(
963 socket_apply_socket_options(s, p->fd);
965 } else if (p->type == SOCKET_SPECIAL) {
967 if ((r = special_address_create(
972 } else if (p->type == SOCKET_FIFO) {
974 if ((r = fifo_address_create(
981 socket_apply_fifo_options(s, p->fd);
982 } else if (p->type == SOCKET_MQUEUE) {
984 if ((r = mq_address_create(
992 assert_not_reached("Unknown port type");
1004 static void socket_unwatch_fds(Socket *s) {
1009 LIST_FOREACH(port, p, s->ports) {
1013 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1017 static int socket_watch_fds(Socket *s) {
1023 LIST_FOREACH(port, p, s->ports) {
1027 p->fd_watch.socket_accept =
1029 p->type == SOCKET_SOCKET &&
1030 socket_address_can_accept(&p->address);
1032 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1039 socket_unwatch_fds(s);
1043 static void socket_set_state(Socket *s, SocketState state) {
1044 SocketState old_state;
1047 old_state = s->state;
1050 if (state != SOCKET_START_PRE &&
1051 state != SOCKET_START_POST &&
1052 state != SOCKET_STOP_PRE &&
1053 state != SOCKET_STOP_PRE_SIGTERM &&
1054 state != SOCKET_STOP_PRE_SIGKILL &&
1055 state != SOCKET_STOP_POST &&
1056 state != SOCKET_FINAL_SIGTERM &&
1057 state != SOCKET_FINAL_SIGKILL) {
1058 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1059 socket_unwatch_control_pid(s);
1060 s->control_command = NULL;
1061 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1064 if (state != SOCKET_LISTENING)
1065 socket_unwatch_fds(s);
1067 if (state != SOCKET_START_POST &&
1068 state != SOCKET_LISTENING &&
1069 state != SOCKET_RUNNING &&
1070 state != SOCKET_STOP_PRE &&
1071 state != SOCKET_STOP_PRE_SIGTERM &&
1072 state != SOCKET_STOP_PRE_SIGKILL)
1073 socket_close_fds(s);
1075 if (state != old_state)
1076 log_debug("%s changed %s -> %s",
1078 socket_state_to_string(old_state),
1079 socket_state_to_string(state));
1081 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1084 static int socket_coldplug(Unit *u) {
1085 Socket *s = SOCKET(u);
1089 assert(s->state == SOCKET_DEAD);
1091 if (s->deserialized_state != s->state) {
1093 if (s->deserialized_state == SOCKET_START_PRE ||
1094 s->deserialized_state == SOCKET_START_POST ||
1095 s->deserialized_state == SOCKET_STOP_PRE ||
1096 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1097 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1098 s->deserialized_state == SOCKET_STOP_POST ||
1099 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1100 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1102 if (s->control_pid <= 0)
1105 if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
1108 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1112 if (s->deserialized_state == SOCKET_START_POST ||
1113 s->deserialized_state == SOCKET_LISTENING ||
1114 s->deserialized_state == SOCKET_RUNNING ||
1115 s->deserialized_state == SOCKET_STOP_PRE ||
1116 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1117 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1118 if ((r = socket_open_fds(s)) < 0)
1121 if (s->deserialized_state == SOCKET_LISTENING)
1122 if ((r = socket_watch_fds(s)) < 0)
1125 socket_set_state(s, s->deserialized_state);
1131 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1140 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1143 if (!(argv = unit_full_printf_strv(UNIT(s), c->argv))) {
1152 UNIT(s)->manager->environment,
1156 UNIT(s)->manager->confirm_spawn,
1157 UNIT(s)->cgroup_bondings,
1158 UNIT(s)->cgroup_attributes,
1168 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1169 /* FIXME: we need to do something here */
1177 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1182 static void socket_enter_dead(Socket *s, SocketResult f) {
1185 if (f != SOCKET_SUCCESS)
1188 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1191 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1193 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1197 if (f != SOCKET_SUCCESS)
1200 socket_unwatch_control_pid(s);
1202 s->control_command_id = SOCKET_EXEC_STOP_POST;
1204 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1205 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1208 socket_set_state(s, SOCKET_STOP_POST);
1210 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1215 log_warning("%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
1216 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1219 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1221 Set *pid_set = NULL;
1222 bool wait_for_exit = false;
1226 if (f != SOCKET_SUCCESS)
1229 if (s->exec_context.kill_mode != KILL_NONE) {
1230 int sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_FINAL_SIGTERM) ? s->exec_context.kill_signal : SIGKILL;
1232 if (s->control_pid > 0) {
1233 if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
1235 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
1237 wait_for_exit = true;
1240 if (s->exec_context.kill_mode == KILL_CONTROL_GROUP) {
1242 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
1247 /* Exclude the control pid from being killed via the cgroup */
1248 if (s->control_pid > 0)
1249 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
1252 r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
1254 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
1255 log_warning("Failed to kill control group: %s", strerror(-r));
1257 wait_for_exit = true;
1264 if (wait_for_exit) {
1265 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1268 socket_set_state(s, state);
1269 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1270 socket_enter_stop_post(s, SOCKET_SUCCESS);
1272 socket_enter_dead(s, SOCKET_SUCCESS);
1277 log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1279 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1280 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1282 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1288 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1292 if (f != SOCKET_SUCCESS)
1295 socket_unwatch_control_pid(s);
1297 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1299 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1300 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1303 socket_set_state(s, SOCKET_STOP_PRE);
1305 socket_enter_stop_post(s, SOCKET_SUCCESS);
1310 log_warning("%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1311 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1314 static void socket_enter_listening(Socket *s) {
1318 r = socket_watch_fds(s);
1320 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1324 socket_set_state(s, SOCKET_LISTENING);
1328 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1331 static void socket_enter_start_post(Socket *s) {
1335 r = socket_open_fds(s);
1337 log_warning("%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1341 socket_unwatch_control_pid(s);
1343 s->control_command_id = SOCKET_EXEC_START_POST;
1345 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1346 r = socket_spawn(s, s->control_command, &s->control_pid);
1348 log_warning("%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1352 socket_set_state(s, SOCKET_START_POST);
1354 socket_enter_listening(s);
1359 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1362 static void socket_enter_start_pre(Socket *s) {
1366 socket_unwatch_control_pid(s);
1368 s->control_command_id = SOCKET_EXEC_START_PRE;
1370 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1371 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1374 socket_set_state(s, SOCKET_START_PRE);
1376 socket_enter_start_post(s);
1381 log_warning("%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1382 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1385 static void socket_enter_running(Socket *s, int cfd) {
1390 dbus_error_init(&error);
1392 /* We don't take connections anymore if we are supposed to
1393 * shut down anyway */
1394 if (unit_pending_inactive(UNIT(s))) {
1395 log_debug("Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1398 close_nointr_nofail(cfd);
1400 /* Flush all sockets by closing and reopening them */
1401 socket_close_fds(s);
1403 r = socket_watch_fds(s);
1405 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1406 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1416 bool pending = false;
1418 /* If there's already a start pending don't bother to
1420 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1421 if (unit_pending_active(u)) {
1427 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1432 socket_set_state(s, SOCKET_RUNNING);
1434 char *prefix, *instance = NULL, *name;
1437 if (s->n_connections >= s->max_connections) {
1438 log_warning("Too many incoming connections (%u)", s->n_connections);
1439 close_nointr_nofail(cfd);
1443 r = socket_instantiate_service(s);
1447 r = instance_from_socket(cfd, s->n_accepted, &instance);
1452 /* ENOTCONN is legitimate if TCP RST was received.
1453 * This connection is over, but the socket unit lives on. */
1454 close_nointr_nofail(cfd);
1458 prefix = unit_name_to_prefix(UNIT(s)->id);
1465 name = unit_name_build(prefix, instance, ".service");
1474 r = unit_add_name(UNIT_DEREF(s->service), name);
1480 service = SERVICE(UNIT_DEREF(s->service));
1481 unit_ref_unset(&s->service);
1484 UNIT(service)->no_gc = false;
1486 unit_choose_id(UNIT(service), name);
1489 r = service_set_socket_fd(service, cfd, s);
1494 s->n_connections ++;
1496 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1500 /* Notify clients about changed counters */
1501 unit_add_to_dbus_queue(UNIT(s));
1507 log_warning("%s failed to queue socket startup job: %s", UNIT(s)->id, bus_error(&error, r));
1508 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1511 close_nointr_nofail(cfd);
1513 dbus_error_free(&error);
1516 static void socket_run_next(Socket *s) {
1520 assert(s->control_command);
1521 assert(s->control_command->command_next);
1523 socket_unwatch_control_pid(s);
1525 s->control_command = s->control_command->command_next;
1527 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1533 log_warning("%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1535 if (s->state == SOCKET_START_POST)
1536 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1537 else if (s->state == SOCKET_STOP_POST)
1538 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1540 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1543 static int socket_start(Unit *u) {
1544 Socket *s = SOCKET(u);
1548 /* We cannot fulfill this request right now, try again later
1550 if (s->state == SOCKET_STOP_PRE ||
1551 s->state == SOCKET_STOP_PRE_SIGKILL ||
1552 s->state == SOCKET_STOP_PRE_SIGTERM ||
1553 s->state == SOCKET_STOP_POST ||
1554 s->state == SOCKET_FINAL_SIGTERM ||
1555 s->state == SOCKET_FINAL_SIGKILL)
1558 if (s->state == SOCKET_START_PRE ||
1559 s->state == SOCKET_START_POST)
1562 /* Cannot run this without the service being around */
1563 if (UNIT_DEREF(s->service)) {
1566 service = SERVICE(UNIT_DEREF(s->service));
1568 if (UNIT(service)->load_state != UNIT_LOADED) {
1569 log_error("Socket service %s not loaded, refusing.", UNIT(service)->id);
1573 /* If the service is already active we cannot start the
1575 if (service->state != SERVICE_DEAD &&
1576 service->state != SERVICE_FAILED &&
1577 service->state != SERVICE_AUTO_RESTART) {
1578 log_error("Socket service %s already active, refusing.", UNIT(service)->id);
1582 #ifdef HAVE_SYSV_COMPAT
1583 if (service->is_sysv) {
1584 log_error("Using SysV services for socket activation is not supported. Refusing.");
1590 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1592 s->result = SOCKET_SUCCESS;
1593 socket_enter_start_pre(s);
1597 static int socket_stop(Unit *u) {
1598 Socket *s = SOCKET(u);
1603 if (s->state == SOCKET_STOP_PRE ||
1604 s->state == SOCKET_STOP_PRE_SIGTERM ||
1605 s->state == SOCKET_STOP_PRE_SIGKILL ||
1606 s->state == SOCKET_STOP_POST ||
1607 s->state == SOCKET_FINAL_SIGTERM ||
1608 s->state == SOCKET_FINAL_SIGKILL)
1611 /* If there's already something running we go directly into
1613 if (s->state == SOCKET_START_PRE ||
1614 s->state == SOCKET_START_POST) {
1615 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1619 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1621 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1625 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1626 Socket *s = SOCKET(u);
1634 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1635 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1636 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1638 if (s->control_pid > 0)
1639 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1641 if (s->control_command_id >= 0)
1642 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1644 LIST_FOREACH(port, p, s->ports) {
1650 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1653 if (p->type == SOCKET_SOCKET) {
1656 if ((r = socket_address_print(&p->address, &t)) < 0)
1659 if (socket_address_family(&p->address) == AF_NETLINK)
1660 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1662 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1664 } else if (p->type == SOCKET_SPECIAL)
1665 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1667 assert(p->type == SOCKET_FIFO);
1668 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1675 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1676 Socket *s = SOCKET(u);
1683 if (streq(key, "state")) {
1686 if ((state = socket_state_from_string(value)) < 0)
1687 log_debug("Failed to parse state value %s", value);
1689 s->deserialized_state = state;
1690 } else if (streq(key, "result")) {
1693 f = socket_result_from_string(value);
1695 log_debug("Failed to parse result value %s", value);
1696 else if (f != SOCKET_SUCCESS)
1699 } else if (streq(key, "n-accepted")) {
1702 if (safe_atou(value, &k) < 0)
1703 log_debug("Failed to parse n-accepted value %s", value);
1706 } else if (streq(key, "control-pid")) {
1709 if (parse_pid(value, &pid) < 0)
1710 log_debug("Failed to parse control-pid value %s", value);
1712 s->control_pid = pid;
1713 } else if (streq(key, "control-command")) {
1714 SocketExecCommand id;
1716 if ((id = socket_exec_command_from_string(value)) < 0)
1717 log_debug("Failed to parse exec-command value %s", value);
1719 s->control_command_id = id;
1720 s->control_command = s->exec_command[id];
1722 } else if (streq(key, "fifo")) {
1726 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1727 log_debug("Failed to parse fifo value %s", value);
1730 LIST_FOREACH(port, p, s->ports)
1731 if (p->type == SOCKET_FIFO &&
1732 streq_ptr(p->path, value+skip))
1737 close_nointr_nofail(p->fd);
1738 p->fd = fdset_remove(fds, fd);
1742 } else if (streq(key, "special")) {
1746 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1747 log_debug("Failed to parse special value %s", value);
1750 LIST_FOREACH(port, p, s->ports)
1751 if (p->type == SOCKET_SPECIAL &&
1752 streq_ptr(p->path, value+skip))
1757 close_nointr_nofail(p->fd);
1758 p->fd = fdset_remove(fds, fd);
1762 } else if (streq(key, "socket")) {
1763 int fd, type, skip = 0;
1766 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1767 log_debug("Failed to parse socket value %s", value);
1770 LIST_FOREACH(port, p, s->ports)
1771 if (socket_address_is(&p->address, value+skip, type))
1776 close_nointr_nofail(p->fd);
1777 p->fd = fdset_remove(fds, fd);
1781 } else if (streq(key, "netlink")) {
1785 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1786 log_debug("Failed to parse socket value %s", value);
1789 LIST_FOREACH(port, p, s->ports)
1790 if (socket_address_is_netlink(&p->address, value+skip))
1795 close_nointr_nofail(p->fd);
1796 p->fd = fdset_remove(fds, fd);
1801 log_debug("Unknown serialization key '%s'", key);
1806 static UnitActiveState socket_active_state(Unit *u) {
1809 return state_translation_table[SOCKET(u)->state];
1812 static const char *socket_sub_state_to_string(Unit *u) {
1815 return socket_state_to_string(SOCKET(u)->state);
1818 static bool socket_check_gc(Unit *u) {
1819 Socket *s = SOCKET(u);
1823 return s->n_connections > 0;
1826 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1827 Socket *s = SOCKET(u);
1833 if (s->state != SOCKET_LISTENING)
1836 log_debug("Incoming traffic on %s", u->id);
1838 if (events != EPOLLIN) {
1840 if (events & EPOLLHUP)
1841 log_error("%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.", u->id);
1843 log_error("%s: Got unexpected poll event (0x%x) on socket.", u->id, events);
1848 if (w->socket_accept) {
1851 if ((cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK)) < 0) {
1856 log_error("Failed to accept socket: %m");
1863 socket_apply_socket_options(s, cfd);
1866 socket_enter_running(s, cfd);
1870 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1873 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1874 Socket *s = SOCKET(u);
1880 if (pid != s->control_pid)
1885 if (is_clean_exit(code, status))
1887 else if (code == CLD_EXITED)
1888 f = SOCKET_FAILURE_EXIT_CODE;
1889 else if (code == CLD_KILLED)
1890 f = SOCKET_FAILURE_SIGNAL;
1891 else if (code == CLD_DUMPED)
1892 f = SOCKET_FAILURE_CORE_DUMP;
1894 assert_not_reached("Unknown code");
1896 if (s->control_command) {
1897 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
1899 if (s->control_command->ignore)
1903 log_full(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1904 "%s control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1906 if (f != SOCKET_SUCCESS)
1909 if (s->control_command &&
1910 s->control_command->command_next &&
1911 f == SOCKET_SUCCESS) {
1913 log_debug("%s running next command for state %s", u->id, socket_state_to_string(s->state));
1916 s->control_command = NULL;
1917 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1919 /* No further commands for this step, so let's figure
1920 * out what to do next */
1922 log_debug("%s got final SIGCHLD for state %s", u->id, socket_state_to_string(s->state));
1926 case SOCKET_START_PRE:
1927 if (f == SOCKET_SUCCESS)
1928 socket_enter_start_post(s);
1930 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
1933 case SOCKET_START_POST:
1934 if (f == SOCKET_SUCCESS)
1935 socket_enter_listening(s);
1937 socket_enter_stop_pre(s, f);
1940 case SOCKET_STOP_PRE:
1941 case SOCKET_STOP_PRE_SIGTERM:
1942 case SOCKET_STOP_PRE_SIGKILL:
1943 socket_enter_stop_post(s, f);
1946 case SOCKET_STOP_POST:
1947 case SOCKET_FINAL_SIGTERM:
1948 case SOCKET_FINAL_SIGKILL:
1949 socket_enter_dead(s, f);
1953 assert_not_reached("Uh, control process died at wrong time.");
1957 /* Notify clients about changed exit status */
1958 unit_add_to_dbus_queue(u);
1961 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1962 Socket *s = SOCKET(u);
1965 assert(elapsed == 1);
1966 assert(w == &s->timer_watch);
1970 case SOCKET_START_PRE:
1971 log_warning("%s starting timed out. Terminating.", u->id);
1972 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1975 case SOCKET_START_POST:
1976 log_warning("%s starting timed out. Stopping.", u->id);
1977 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
1980 case SOCKET_STOP_PRE:
1981 log_warning("%s stopping timed out. Terminating.", u->id);
1982 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1985 case SOCKET_STOP_PRE_SIGTERM:
1986 if (s->exec_context.send_sigkill) {
1987 log_warning("%s stopping timed out. Killing.", u->id);
1988 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
1990 log_warning("%s stopping timed out. Skipping SIGKILL. Ignoring.", u->id);
1991 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
1995 case SOCKET_STOP_PRE_SIGKILL:
1996 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
1997 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2000 case SOCKET_STOP_POST:
2001 log_warning("%s stopping timed out (2). Terminating.", u->id);
2002 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2005 case SOCKET_FINAL_SIGTERM:
2006 if (s->exec_context.send_sigkill) {
2007 log_warning("%s stopping timed out (2). Killing.", u->id);
2008 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2010 log_warning("%s stopping timed out (2). Skipping SIGKILL. Ignoring.", u->id);
2011 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2015 case SOCKET_FINAL_SIGKILL:
2016 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
2017 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2021 assert_not_reached("Timeout at wrong time.");
2025 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2034 /* Called from the service code for requesting our fds */
2037 LIST_FOREACH(port, p, s->ports)
2047 if (!(rfds = new(int, rn_fds)))
2051 LIST_FOREACH(port, p, s->ports)
2055 assert(k == rn_fds);
2063 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2066 /* The service is dead. Dang!
2068 * This is strictly for one-instance-for-all-connections
2071 if (s->state == SOCKET_RUNNING) {
2072 log_debug("%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2073 if (failed_permanent)
2074 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2076 socket_enter_listening(s);
2080 void socket_connection_unref(Socket *s) {
2083 /* The service is dead. Yay!
2085 * This is strictly for one-instance-per-connection
2088 assert(s->n_connections > 0);
2091 log_debug("%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2094 static void socket_reset_failed(Unit *u) {
2095 Socket *s = SOCKET(u);
2099 if (s->state == SOCKET_FAILED)
2100 socket_set_state(s, SOCKET_DEAD);
2102 s->result = SOCKET_SUCCESS;
2105 static int socket_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
2106 Socket *s = SOCKET(u);
2108 Set *pid_set = NULL;
2112 if (who == KILL_MAIN) {
2113 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Socket units have no main processes");
2117 if (s->control_pid <= 0 && who == KILL_CONTROL) {
2118 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2122 if (who == KILL_CONTROL || who == KILL_ALL)
2123 if (s->control_pid > 0)
2124 if (kill(s->control_pid, signo) < 0)
2127 if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
2130 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
2133 /* Exclude the control pid from being killed via the cgroup */
2134 if (s->control_pid > 0)
2135 if ((q = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0) {
2140 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
2142 if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2153 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2154 [SOCKET_DEAD] = "dead",
2155 [SOCKET_START_PRE] = "start-pre",
2156 [SOCKET_START_POST] = "start-post",
2157 [SOCKET_LISTENING] = "listening",
2158 [SOCKET_RUNNING] = "running",
2159 [SOCKET_STOP_PRE] = "stop-pre",
2160 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2161 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2162 [SOCKET_STOP_POST] = "stop-post",
2163 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2164 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2165 [SOCKET_FAILED] = "failed"
2168 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2170 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2171 [SOCKET_EXEC_START_PRE] = "StartPre",
2172 [SOCKET_EXEC_START_POST] = "StartPost",
2173 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2174 [SOCKET_EXEC_STOP_POST] = "StopPost"
2177 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2179 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2180 [SOCKET_SUCCESS] = "success",
2181 [SOCKET_FAILURE_RESOURCES] = "resources",
2182 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2183 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2184 [SOCKET_FAILURE_SIGNAL] = "signal",
2185 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2186 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2189 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2191 const UnitVTable socket_vtable = {
2192 .object_size = sizeof(Socket),
2198 .init = socket_init,
2199 .done = socket_done,
2200 .load = socket_load,
2202 .kill = socket_kill,
2204 .coldplug = socket_coldplug,
2206 .dump = socket_dump,
2208 .start = socket_start,
2209 .stop = socket_stop,
2211 .serialize = socket_serialize,
2212 .deserialize_item = socket_deserialize_item,
2214 .active_state = socket_active_state,
2215 .sub_state_to_string = socket_sub_state_to_string,
2217 .check_gc = socket_check_gc,
2219 .fd_event = socket_fd_event,
2220 .sigchld_event = socket_sigchld_event,
2221 .timer_event = socket_timer_event,
2223 .reset_failed = socket_reset_failed,
2225 .bus_interface = "org.freedesktop.systemd1.Socket",
2226 .bus_message_handler = bus_socket_message_handler,
2227 .bus_invalidating_properties = bus_socket_invalidating_properties,
2229 .status_message_formats = {
2230 /*.starting_stopping = {
2231 [0] = "Starting socket %s...",
2232 [1] = "Stopping socket %s...",
2234 .finished_start_job = {
2235 [JOB_DONE] = "Listening on %s.",
2236 [JOB_FAILED] = "Failed to listen on %s.",
2237 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2238 [JOB_TIMEOUT] = "Timed out starting %s.",
2240 .finished_stop_job = {
2241 [JOB_DONE] = "Closed %s.",
2242 [JOB_FAILED] = "Failed stopping %s.",
2243 [JOB_TIMEOUT] = "Timed out stopping %s.",