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>
30 #include <netinet/tcp.h>
33 #include <attr/xattr.h>
40 #include "load-dropin.h"
41 #include "load-fragment.h"
44 #include "path-util.h"
45 #include "unit-name.h"
46 #include "unit-printf.h"
47 #include "dbus-socket.h"
51 #include "exit-status.h"
53 #include "smack-util.h"
55 #include "bus-error.h"
57 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
58 [SOCKET_DEAD] = UNIT_INACTIVE,
59 [SOCKET_START_PRE] = UNIT_ACTIVATING,
60 [SOCKET_START_POST] = UNIT_ACTIVATING,
61 [SOCKET_LISTENING] = UNIT_ACTIVE,
62 [SOCKET_RUNNING] = UNIT_ACTIVE,
63 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
64 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
65 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
66 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
67 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
68 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
69 [SOCKET_FAILED] = UNIT_FAILED
72 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
73 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
75 static void socket_init(Unit *u) {
76 Socket *s = SOCKET(u);
79 assert(u->load_state == UNIT_STUB);
81 s->backlog = SOMAXCONN;
82 s->timeout_usec = u->manager->default_timeout_start_usec;
83 s->directory_mode = 0755;
84 s->socket_mode = 0666;
86 s->max_connections = 64;
93 exec_context_init(&s->exec_context);
94 s->exec_context.std_output = u->manager->default_std_output;
95 s->exec_context.std_error = u->manager->default_std_error;
96 kill_context_init(&s->kill_context);
97 cgroup_context_init(&s->cgroup_context);
99 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
102 static void socket_unwatch_control_pid(Socket *s) {
105 if (s->control_pid <= 0)
108 unit_unwatch_pid(UNIT(s), s->control_pid);
112 void socket_free_ports(Socket *s) {
117 while ((p = s->ports)) {
118 LIST_REMOVE(port, s->ports, p);
120 sd_event_source_unref(p->event_source);
123 close_nointr_nofail(p->fd);
130 static void socket_done(Unit *u) {
131 Socket *s = SOCKET(u);
135 socket_free_ports(s);
137 exec_context_done(&s->exec_context, manager_is_reloading_or_reexecuting(u->manager));
138 cgroup_context_init(&s->cgroup_context);
140 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
141 s->control_command = NULL;
143 socket_unwatch_control_pid(s);
145 unit_ref_unset(&s->service);
147 free(s->tcp_congestion);
148 s->tcp_congestion = NULL;
150 free(s->bind_to_device);
151 s->bind_to_device = NULL;
154 free(s->smack_ip_in);
155 free(s->smack_ip_out);
157 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
160 static int socket_arm_timer(Socket *s) {
165 if (s->timeout_usec <= 0) {
166 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
170 if (s->timer_event_source) {
171 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec);
175 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
178 return sd_event_add_monotonic(UNIT(s)->manager->event, now(CLOCK_MONOTONIC) + s->timeout_usec, 0, socket_dispatch_timer, s, &s->timer_event_source);
181 static int socket_instantiate_service(Socket *s) {
188 /* This fills in s->service if it isn't filled in yet. For
189 * Accept=yes sockets we create the next connection service
190 * here. For Accept=no this is mostly a NOP since the service
191 * is figured out at load time anyway. */
193 if (UNIT_DEREF(s->service))
198 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
201 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
207 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
213 #ifdef HAVE_SYSV_COMPAT
214 if (SERVICE(u)->is_sysv) {
215 log_error("Using SysV services for socket activation is not supported. Refusing.");
221 unit_ref_set(&s->service, u);
223 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
226 static bool have_non_accept_socket(Socket *s) {
234 LIST_FOREACH(port, p, s->ports) {
236 if (p->type != SOCKET_SOCKET)
239 if (!socket_address_can_accept(&p->address))
246 static int socket_verify(Socket *s) {
249 if (UNIT(s)->load_state != UNIT_LOADED)
253 log_error_unit(UNIT(s)->id,
254 "%s lacks Listen setting. Refusing.", UNIT(s)->id);
258 if (s->accept && have_non_accept_socket(s)) {
259 log_error_unit(UNIT(s)->id,
260 "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
265 if (s->accept && s->max_connections <= 0) {
266 log_error_unit(UNIT(s)->id,
267 "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
271 if (s->accept && UNIT_DEREF(s->service)) {
272 log_error_unit(UNIT(s)->id,
273 "Explicit service configuration for accepting sockets not supported on %s. Refusing.",
278 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
279 log_error_unit(UNIT(s)->id,
280 "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.",
288 static int socket_add_mount_links(Socket *s) {
294 LIST_FOREACH(port, p, s->ports) {
295 const char *path = NULL;
297 if (p->type == SOCKET_SOCKET)
298 path = socket_address_get_path(&p->address);
299 else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL)
305 r = unit_require_mounts_for(UNIT(s), path);
313 static int socket_add_device_link(Socket *s) {
319 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
322 if (asprintf(&t, "/sys/subsystem/net/devices/%s", s->bind_to_device) < 0)
325 r = unit_add_node_link(UNIT(s), t, false);
331 static int socket_add_default_dependencies(Socket *s) {
335 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
339 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
340 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
345 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
348 _pure_ static bool socket_has_exec(Socket *s) {
352 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
353 if (s->exec_command[i])
359 static int socket_load(Unit *u) {
360 Socket *s = SOCKET(u);
364 assert(u->load_state == UNIT_STUB);
366 if ((r = unit_load_fragment_and_dropin(u)) < 0)
369 /* This is a new unit? Then let's add in some extras */
370 if (u->load_state == UNIT_LOADED) {
372 if (have_non_accept_socket(s)) {
374 if (!UNIT_DEREF(s->service)) {
377 r = unit_load_related_unit(u, ".service", &x);
381 unit_ref_set(&s->service, x);
384 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
389 if ((r = socket_add_mount_links(s)) < 0)
392 if ((r = socket_add_device_link(s)) < 0)
395 if (socket_has_exec(s))
396 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
399 r = unit_add_default_slice(u);
403 if (UNIT(s)->default_dependencies)
404 if ((r = socket_add_default_dependencies(s)) < 0)
407 r = unit_exec_context_defaults(u, &s->exec_context);
412 return socket_verify(s);
415 _const_ static const char* listen_lookup(int family, int type) {
417 if (family == AF_NETLINK)
418 return "ListenNetlink";
420 if (type == SOCK_STREAM)
421 return "ListenStream";
422 else if (type == SOCK_DGRAM)
423 return "ListenDatagram";
424 else if (type == SOCK_SEQPACKET)
425 return "ListenSequentialPacket";
427 assert_not_reached("Unknown socket type");
431 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
434 Socket *s = SOCKET(u);
442 p2 = strappend(prefix, "\t");
443 prefix2 = p2 ? p2 : prefix;
446 "%sSocket State: %s\n"
448 "%sBindIPv6Only: %s\n"
450 "%sSocketMode: %04o\n"
451 "%sDirectoryMode: %04o\n"
454 "%sTransparent: %s\n"
456 "%sPassCredentials: %s\n"
457 "%sPassSecurity: %s\n"
458 "%sTCPCongestion: %s\n",
459 prefix, socket_state_to_string(s->state),
460 prefix, socket_result_to_string(s->result),
461 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
463 prefix, s->socket_mode,
464 prefix, s->directory_mode,
465 prefix, yes_no(s->keep_alive),
466 prefix, yes_no(s->free_bind),
467 prefix, yes_no(s->transparent),
468 prefix, yes_no(s->broadcast),
469 prefix, yes_no(s->pass_cred),
470 prefix, yes_no(s->pass_sec),
471 prefix, strna(s->tcp_congestion));
473 if (s->control_pid > 0)
475 "%sControl PID: %lu\n",
476 prefix, (unsigned long) s->control_pid);
478 if (s->bind_to_device)
480 "%sBindToDevice: %s\n",
481 prefix, s->bind_to_device);
486 "%sNConnections: %u\n"
487 "%sMaxConnections: %u\n",
488 prefix, s->n_accepted,
489 prefix, s->n_connections,
490 prefix, s->max_connections);
492 if (s->priority >= 0)
495 prefix, s->priority);
497 if (s->receive_buffer > 0)
499 "%sReceiveBuffer: %zu\n",
500 prefix, s->receive_buffer);
502 if (s->send_buffer > 0)
504 "%sSendBuffer: %zu\n",
505 prefix, s->send_buffer);
517 if (s->pipe_size > 0)
520 prefix, s->pipe_size);
527 if (s->mq_maxmsg > 0)
529 "%sMessageQueueMaxMessages: %li\n",
530 prefix, s->mq_maxmsg);
532 if (s->mq_msgsize > 0)
534 "%sMessageQueueMessageSize: %li\n",
535 prefix, s->mq_msgsize);
540 prefix, yes_no(s->reuse_port));
544 "%sSmackLabel: %s\n",
549 "%sSmackLabelIPIn: %s\n",
550 prefix, s->smack_ip_in);
554 "%sSmackLabelIPOut: %s\n",
555 prefix, s->smack_ip_out);
557 LIST_FOREACH(port, p, s->ports) {
559 if (p->type == SOCKET_SOCKET) {
564 if ((r = socket_address_print(&p->address, &k)) < 0)
569 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
571 } else if (p->type == SOCKET_SPECIAL)
572 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
573 else if (p->type == SOCKET_MQUEUE)
574 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
576 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
579 exec_context_dump(&s->exec_context, f, prefix);
580 kill_context_dump(&s->kill_context, f, prefix);
582 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
583 if (!s->exec_command[c])
586 fprintf(f, "%s-> %s:\n",
587 prefix, socket_exec_command_to_string(c));
589 exec_command_dump_list(s->exec_command[c], f, prefix2);
595 static int instance_from_socket(int fd, unsigned nr, char **instance) {
600 struct sockaddr_un un;
601 struct sockaddr_in in;
602 struct sockaddr_in6 in6;
603 struct sockaddr_storage storage;
610 if (getsockname(fd, &local.sa, &l) < 0)
614 if (getpeername(fd, &remote.sa, &l) < 0)
617 switch (local.sa.sa_family) {
621 a = ntohl(local.in.sin_addr.s_addr),
622 b = ntohl(remote.in.sin_addr.s_addr);
625 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
627 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
628 ntohs(local.in.sin_port),
629 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
630 ntohs(remote.in.sin_port)) < 0)
637 static const unsigned char ipv4_prefix[] = {
638 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
641 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
642 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
644 *a = local.in6.sin6_addr.s6_addr+12,
645 *b = remote.in6.sin6_addr.s6_addr+12;
648 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
650 a[0], a[1], a[2], a[3],
651 ntohs(local.in6.sin6_port),
652 b[0], b[1], b[2], b[3],
653 ntohs(remote.in6.sin6_port)) < 0)
656 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
661 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
662 ntohs(local.in6.sin6_port),
663 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
664 ntohs(remote.in6.sin6_port)) < 0)
675 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
681 (unsigned long) ucred.pid,
682 (unsigned long) ucred.uid) < 0)
689 assert_not_reached("Unhandled socket type.");
696 static void socket_close_fds(Socket *s) {
701 LIST_FOREACH(port, p, s->ports) {
703 p->event_source = sd_event_source_unref(p->event_source);
708 close_nointr_nofail(p->fd);
710 /* One little note: we should never delete any sockets
711 * in the file system here! After all some other
712 * process we spawned might still have a reference of
713 * this fd and wants to continue to use it. Therefore
714 * we delete sockets in the file system before we
715 * create a new one, not after we stopped using
722 static void socket_apply_socket_options(Socket *s, int fd) {
727 int b = s->keep_alive;
728 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
729 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
734 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
735 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
740 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
741 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
746 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
747 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
750 if (s->priority >= 0)
751 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
752 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
754 if (s->receive_buffer > 0) {
755 int value = (int) s->receive_buffer;
757 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
759 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
760 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
761 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
764 if (s->send_buffer > 0) {
765 int value = (int) s->send_buffer;
766 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
767 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
768 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
772 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
773 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
776 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
777 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
779 if (s->ip_ttl >= 0) {
782 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
784 if (socket_ipv6_is_supported())
785 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
788 errno = EAFNOSUPPORT;
792 log_warning_unit(UNIT(s)->id,
793 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
796 if (s->tcp_congestion)
797 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
798 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
801 int b = s->reuse_port;
802 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)) < 0)
803 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
807 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
808 log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
811 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
812 log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
815 static void socket_apply_fifo_options(Socket *s, int fd) {
819 if (s->pipe_size > 0)
820 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
821 log_warning_unit(UNIT(s)->id,
825 if (smack_label_fd(fd, s->smack) < 0)
826 log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
829 static int fifo_address_create(
831 mode_t directory_mode,
842 mkdir_parents_label(path, directory_mode);
844 r = label_context_set(path, S_IFIFO);
848 /* Enforce the right access mode for the fifo */
849 old_mask = umask(~ socket_mode);
851 /* Include the original umask in our mask */
852 umask(~socket_mode | old_mask);
854 r = mkfifo(path, socket_mode);
857 if (r < 0 && errno != EEXIST) {
862 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
867 label_context_clear();
869 if (fstat(fd, &st) < 0) {
874 if (!S_ISFIFO(st.st_mode) ||
875 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
876 st.st_uid != getuid() ||
877 st.st_gid != getgid()) {
887 label_context_clear();
890 close_nointr_nofail(fd);
895 static int special_address_create(
905 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
910 if (fstat(fd, &st) < 0) {
915 /* Check whether this is a /proc, /sys or /dev file or char device */
916 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
926 close_nointr_nofail(fd);
931 static int mq_address_create(
941 struct mq_attr _attr, *attr = NULL;
946 if (maxmsg > 0 && msgsize > 0) {
948 _attr.mq_flags = O_NONBLOCK;
949 _attr.mq_maxmsg = maxmsg;
950 _attr.mq_msgsize = msgsize;
954 /* Enforce the right access mode for the mq */
955 old_mask = umask(~ mq_mode);
957 /* Include the original umask in our mask */
958 umask(~mq_mode | old_mask);
960 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
968 if (fstat(fd, &st) < 0) {
973 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
974 st.st_uid != getuid() ||
975 st.st_gid != getgid()) {
986 close_nointr_nofail(fd);
991 static int socket_open_fds(Socket *s) {
995 bool know_label = false;
999 LIST_FOREACH(port, p, s->ports) {
1004 if (p->type == SOCKET_SOCKET) {
1008 if ((r = socket_instantiate_service(s)) < 0)
1011 if (UNIT_ISSET(s->service) &&
1012 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1013 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1024 r = socket_address_listen(
1026 SOCK_CLOEXEC|SOCK_NONBLOCK,
1039 socket_apply_socket_options(s, p->fd);
1041 } else if (p->type == SOCKET_SPECIAL) {
1043 r = special_address_create(
1049 } else if (p->type == SOCKET_FIFO) {
1051 r = fifo_address_create(
1059 socket_apply_fifo_options(s, p->fd);
1060 } else if (p->type == SOCKET_MQUEUE) {
1062 r = mq_address_create(
1071 assert_not_reached("Unknown port type");
1078 socket_close_fds(s);
1083 static void socket_unwatch_fds(Socket *s) {
1089 LIST_FOREACH(port, p, s->ports) {
1093 if (p->event_source) {
1094 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_OFF);
1096 log_debug_unit(UNIT(s)->id, "Failed to disable event source.");
1101 static int socket_watch_fds(Socket *s) {
1107 LIST_FOREACH(port, p, s->ports) {
1111 if (p->event_source)
1112 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1114 r = sd_event_add_io(UNIT(s)->manager->event, p->fd, EPOLLIN, socket_dispatch_io, p, &p->event_source);
1117 log_warning_unit(UNIT(s)->id, "Failed to watch listening fds: %s", strerror(-r));
1125 socket_unwatch_fds(s);
1129 static void socket_set_state(Socket *s, SocketState state) {
1130 SocketState old_state;
1133 old_state = s->state;
1136 if (state != SOCKET_START_PRE &&
1137 state != SOCKET_START_POST &&
1138 state != SOCKET_STOP_PRE &&
1139 state != SOCKET_STOP_PRE_SIGTERM &&
1140 state != SOCKET_STOP_PRE_SIGKILL &&
1141 state != SOCKET_STOP_POST &&
1142 state != SOCKET_FINAL_SIGTERM &&
1143 state != SOCKET_FINAL_SIGKILL) {
1145 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1146 socket_unwatch_control_pid(s);
1147 s->control_command = NULL;
1148 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1151 if (state != SOCKET_LISTENING)
1152 socket_unwatch_fds(s);
1154 if (state != SOCKET_START_POST &&
1155 state != SOCKET_LISTENING &&
1156 state != SOCKET_RUNNING &&
1157 state != SOCKET_STOP_PRE &&
1158 state != SOCKET_STOP_PRE_SIGTERM &&
1159 state != SOCKET_STOP_PRE_SIGKILL)
1160 socket_close_fds(s);
1162 if (state != old_state)
1163 log_debug_unit(UNIT(s)->id,
1164 "%s changed %s -> %s", UNIT(s)->id,
1165 socket_state_to_string(old_state),
1166 socket_state_to_string(state));
1168 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1171 static int socket_coldplug(Unit *u) {
1172 Socket *s = SOCKET(u);
1176 assert(s->state == SOCKET_DEAD);
1178 if (s->deserialized_state != s->state) {
1180 if (s->deserialized_state == SOCKET_START_PRE ||
1181 s->deserialized_state == SOCKET_START_POST ||
1182 s->deserialized_state == SOCKET_STOP_PRE ||
1183 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1184 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1185 s->deserialized_state == SOCKET_STOP_POST ||
1186 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1187 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1189 if (s->control_pid <= 0)
1192 r = unit_watch_pid(UNIT(s), s->control_pid);
1196 r = socket_arm_timer(s);
1201 if (s->deserialized_state == SOCKET_START_POST ||
1202 s->deserialized_state == SOCKET_LISTENING ||
1203 s->deserialized_state == SOCKET_RUNNING ||
1204 s->deserialized_state == SOCKET_STOP_PRE ||
1205 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1206 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL) {
1207 r = socket_open_fds(s);
1212 if (s->deserialized_state == SOCKET_LISTENING) {
1213 r = socket_watch_fds(s);
1218 socket_set_state(s, s->deserialized_state);
1224 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1233 unit_realize_cgroup(UNIT(s));
1235 r = socket_arm_timer(s);
1239 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1247 UNIT(s)->manager->environment,
1251 UNIT(s)->manager->confirm_spawn,
1252 UNIT(s)->manager->cgroup_supported,
1253 UNIT(s)->cgroup_path,
1262 r = unit_watch_pid(UNIT(s), pid);
1264 /* FIXME: we need to do something here */
1272 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1277 static void socket_enter_dead(Socket *s, SocketResult f) {
1280 if (f != SOCKET_SUCCESS)
1283 exec_context_tmp_dirs_done(&s->exec_context);
1284 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1287 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1289 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1293 if (f != SOCKET_SUCCESS)
1296 socket_unwatch_control_pid(s);
1298 s->control_command_id = SOCKET_EXEC_STOP_POST;
1300 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1301 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1304 socket_set_state(s, SOCKET_STOP_POST);
1306 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1311 log_warning_unit(UNIT(s)->id,
1312 "%s failed to run 'stop-post' task: %s",
1313 UNIT(s)->id, strerror(-r));
1314 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1317 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1322 if (f != SOCKET_SUCCESS)
1325 r = unit_kill_context(
1328 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1336 r = socket_arm_timer(s);
1340 socket_set_state(s, state);
1341 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1342 socket_enter_stop_post(s, SOCKET_SUCCESS);
1344 socket_enter_dead(s, SOCKET_SUCCESS);
1349 log_warning_unit(UNIT(s)->id,
1350 "%s failed to kill processes: %s",
1351 UNIT(s)->id, strerror(-r));
1353 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1354 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1356 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1359 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1363 if (f != SOCKET_SUCCESS)
1366 socket_unwatch_control_pid(s);
1368 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1370 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1371 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1374 socket_set_state(s, SOCKET_STOP_PRE);
1376 socket_enter_stop_post(s, SOCKET_SUCCESS);
1381 log_warning_unit(UNIT(s)->id,
1382 "%s failed to run 'stop-pre' task: %s",
1383 UNIT(s)->id, strerror(-r));
1384 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1387 static void socket_enter_listening(Socket *s) {
1391 r = socket_watch_fds(s);
1393 log_warning_unit(UNIT(s)->id,
1394 "%s failed to watch sockets: %s",
1395 UNIT(s)->id, strerror(-r));
1399 socket_set_state(s, SOCKET_LISTENING);
1403 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1406 static void socket_enter_start_post(Socket *s) {
1410 r = socket_open_fds(s);
1412 log_warning_unit(UNIT(s)->id,
1413 "%s failed to listen on sockets: %s",
1414 UNIT(s)->id, strerror(-r));
1418 socket_unwatch_control_pid(s);
1420 s->control_command_id = SOCKET_EXEC_START_POST;
1422 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1423 r = socket_spawn(s, s->control_command, &s->control_pid);
1425 log_warning_unit(UNIT(s)->id,
1426 "%s failed to run 'start-post' task: %s",
1427 UNIT(s)->id, strerror(-r));
1431 socket_set_state(s, SOCKET_START_POST);
1433 socket_enter_listening(s);
1438 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1441 static void socket_enter_start_pre(Socket *s) {
1445 socket_unwatch_control_pid(s);
1447 s->control_command_id = SOCKET_EXEC_START_PRE;
1449 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1450 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1453 socket_set_state(s, SOCKET_START_PRE);
1455 socket_enter_start_post(s);
1460 log_warning_unit(UNIT(s)->id,
1461 "%s failed to run 'start-pre' task: %s",
1462 UNIT(s)->id, strerror(-r));
1463 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1466 static void socket_enter_running(Socket *s, int cfd) {
1467 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1472 /* We don't take connections anymore if we are supposed to
1473 * shut down anyway */
1474 if (unit_stop_pending(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_active_or_pending(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 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
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);
1550 name = unit_name_build(prefix, instance, ".service");
1557 r = unit_add_name(UNIT_DEREF(s->service), name);
1561 service = SERVICE(UNIT_DEREF(s->service));
1562 unit_ref_unset(&s->service);
1565 UNIT(service)->no_gc = false;
1567 unit_choose_id(UNIT(service), name);
1569 r = service_set_socket_fd(service, cfd, s);
1574 s->n_connections ++;
1576 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1580 /* Notify clients about changed counters */
1581 unit_add_to_dbus_queue(UNIT(s));
1587 log_warning_unit(UNIT(s)->id,
1588 "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1590 cfd >= 0 ? "template" : "non-template",
1591 bus_error_message(&error, r));
1592 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1595 close_nointr_nofail(cfd);
1598 static void socket_run_next(Socket *s) {
1602 assert(s->control_command);
1603 assert(s->control_command->command_next);
1605 socket_unwatch_control_pid(s);
1607 s->control_command = s->control_command->command_next;
1609 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1615 log_warning_unit(UNIT(s)->id,
1616 "%s failed to run next task: %s",
1617 UNIT(s)->id, strerror(-r));
1619 if (s->state == SOCKET_START_POST)
1620 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1621 else if (s->state == SOCKET_STOP_POST)
1622 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1624 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1627 static int socket_start(Unit *u) {
1628 Socket *s = SOCKET(u);
1632 /* We cannot fulfill this request right now, try again later
1634 if (s->state == SOCKET_STOP_PRE ||
1635 s->state == SOCKET_STOP_PRE_SIGKILL ||
1636 s->state == SOCKET_STOP_PRE_SIGTERM ||
1637 s->state == SOCKET_STOP_POST ||
1638 s->state == SOCKET_FINAL_SIGTERM ||
1639 s->state == SOCKET_FINAL_SIGKILL)
1642 if (s->state == SOCKET_START_PRE ||
1643 s->state == SOCKET_START_POST)
1646 /* Cannot run this without the service being around */
1647 if (UNIT_ISSET(s->service)) {
1650 service = SERVICE(UNIT_DEREF(s->service));
1652 if (UNIT(service)->load_state != UNIT_LOADED) {
1653 log_error_unit(u->id,
1654 "Socket service %s not loaded, refusing.",
1659 /* If the service is already active we cannot start the
1661 if (service->state != SERVICE_DEAD &&
1662 service->state != SERVICE_FAILED &&
1663 service->state != SERVICE_AUTO_RESTART) {
1664 log_error_unit(u->id,
1665 "Socket service %s already active, refusing.",
1670 #ifdef HAVE_SYSV_COMPAT
1671 if (service->is_sysv) {
1672 log_error_unit(u->id,
1673 "Using SysV services for socket activation is not supported. Refusing.");
1679 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1681 s->result = SOCKET_SUCCESS;
1682 socket_enter_start_pre(s);
1686 static int socket_stop(Unit *u) {
1687 Socket *s = SOCKET(u);
1692 if (s->state == SOCKET_STOP_PRE ||
1693 s->state == SOCKET_STOP_PRE_SIGTERM ||
1694 s->state == SOCKET_STOP_PRE_SIGKILL ||
1695 s->state == SOCKET_STOP_POST ||
1696 s->state == SOCKET_FINAL_SIGTERM ||
1697 s->state == SOCKET_FINAL_SIGKILL)
1700 /* If there's already something running we go directly into
1702 if (s->state == SOCKET_START_PRE ||
1703 s->state == SOCKET_START_POST) {
1704 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1708 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1710 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1714 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1715 Socket *s = SOCKET(u);
1723 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1724 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1725 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1727 if (s->control_pid > 0)
1728 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1730 if (s->control_command_id >= 0)
1731 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1733 LIST_FOREACH(port, p, s->ports) {
1739 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1742 if (p->type == SOCKET_SOCKET) {
1745 r = socket_address_print(&p->address, &t);
1749 if (socket_address_family(&p->address) == AF_NETLINK)
1750 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1752 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1754 } else if (p->type == SOCKET_SPECIAL)
1755 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1756 else if (p->type == SOCKET_MQUEUE)
1757 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1759 assert(p->type == SOCKET_FIFO);
1760 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1764 exec_context_serialize(&s->exec_context, UNIT(s), f);
1769 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1770 Socket *s = SOCKET(u);
1777 if (streq(key, "state")) {
1780 state = socket_state_from_string(value);
1782 log_debug_unit(u->id,
1783 "Failed to parse state value %s", value);
1785 s->deserialized_state = state;
1786 } else if (streq(key, "result")) {
1789 f = socket_result_from_string(value);
1791 log_debug_unit(u->id,
1792 "Failed to parse result value %s", value);
1793 else if (f != SOCKET_SUCCESS)
1796 } else if (streq(key, "n-accepted")) {
1799 if (safe_atou(value, &k) < 0)
1800 log_debug_unit(u->id,
1801 "Failed to parse n-accepted value %s", value);
1804 } else if (streq(key, "control-pid")) {
1807 if (parse_pid(value, &pid) < 0)
1808 log_debug_unit(u->id,
1809 "Failed to parse control-pid value %s", value);
1811 s->control_pid = pid;
1812 } else if (streq(key, "control-command")) {
1813 SocketExecCommand id;
1815 id = socket_exec_command_from_string(value);
1817 log_debug_unit(u->id,
1818 "Failed to parse exec-command value %s", value);
1820 s->control_command_id = id;
1821 s->control_command = s->exec_command[id];
1823 } else if (streq(key, "fifo")) {
1827 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1828 log_debug_unit(u->id,
1829 "Failed to parse fifo value %s", value);
1832 LIST_FOREACH(port, p, s->ports)
1833 if (p->type == SOCKET_FIFO &&
1834 streq_ptr(p->path, value+skip))
1839 close_nointr_nofail(p->fd);
1840 p->fd = fdset_remove(fds, fd);
1844 } else if (streq(key, "special")) {
1848 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1849 log_debug_unit(u->id,
1850 "Failed to parse special value %s", value);
1853 LIST_FOREACH(port, p, s->ports)
1854 if (p->type == SOCKET_SPECIAL &&
1855 streq_ptr(p->path, value+skip))
1860 close_nointr_nofail(p->fd);
1861 p->fd = fdset_remove(fds, fd);
1865 } else if (streq(key, "mqueue")) {
1869 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1870 log_debug_unit(u->id,
1871 "Failed to parse mqueue value %s", value);
1874 LIST_FOREACH(port, p, s->ports)
1875 if (p->type == SOCKET_MQUEUE &&
1876 streq_ptr(p->path, value+skip))
1881 close_nointr_nofail(p->fd);
1882 p->fd = fdset_remove(fds, fd);
1886 } else if (streq(key, "socket")) {
1887 int fd, type, skip = 0;
1890 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1891 log_debug_unit(u->id,
1892 "Failed to parse socket value %s", value);
1895 LIST_FOREACH(port, p, s->ports)
1896 if (socket_address_is(&p->address, value+skip, type))
1901 close_nointr_nofail(p->fd);
1902 p->fd = fdset_remove(fds, fd);
1906 } else if (streq(key, "netlink")) {
1910 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1911 log_debug_unit(u->id,
1912 "Failed to parse socket value %s", value);
1915 LIST_FOREACH(port, p, s->ports)
1916 if (socket_address_is_netlink(&p->address, value+skip))
1921 close_nointr_nofail(p->fd);
1922 p->fd = fdset_remove(fds, fd);
1925 } else if (streq(key, "tmp-dir")) {
1932 s->exec_context.tmp_dir = t;
1933 } else if (streq(key, "var-tmp-dir")) {
1940 s->exec_context.var_tmp_dir = t;
1942 log_debug_unit(UNIT(s)->id,
1943 "Unknown serialization key '%s'", key);
1948 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1949 Socket *s = SOCKET(u);
1954 LIST_FOREACH(port, p, s->ports) {
1958 if (p->type != SOCKET_SOCKET)
1964 FDSET_FOREACH(fd, fds, i) {
1965 if (socket_address_matches_fd(&p->address, fd)) {
1966 p->fd = fdset_remove(fds, fd);
1967 s->deserialized_state = SOCKET_LISTENING;
1976 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1979 return state_translation_table[SOCKET(u)->state];
1982 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1985 return socket_state_to_string(SOCKET(u)->state);
1988 const char* socket_port_type_to_string(SocketPort *p) {
1996 switch (p->address.type) {
2004 case SOCK_SEQPACKET:
2005 return "SequentialPacket";
2008 if (socket_address_family(&p->address) == AF_NETLINK)
2015 case SOCKET_SPECIAL:
2019 return "MessageQueue";
2029 _pure_ static bool socket_check_gc(Unit *u) {
2030 Socket *s = SOCKET(u);
2034 return s->n_connections > 0;
2037 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2038 SocketPort *p = userdata;
2044 if (p->socket->state != SOCKET_LISTENING)
2047 log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
2049 if (revents != EPOLLIN) {
2051 if (revents & EPOLLHUP)
2052 log_error_unit(UNIT(p->socket)->id,
2053 "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
2054 UNIT(p->socket)->id);
2056 log_error_unit(UNIT(p->socket)->id,
2057 "%s: Got unexpected poll event (0x%x) on socket.",
2058 UNIT(p->socket)->id, revents);
2063 if (p->socket->accept &&
2064 p->type == SOCKET_SOCKET &&
2065 socket_address_can_accept(&p->address)) {
2069 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2075 log_error_unit(UNIT(p->socket)->id,
2076 "Failed to accept socket: %m");
2083 socket_apply_socket_options(p->socket, cfd);
2086 socket_enter_running(p->socket, cfd);
2090 socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2094 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2095 Socket *s = SOCKET(u);
2101 if (pid != s->control_pid)
2106 if (is_clean_exit(code, status, NULL))
2108 else if (code == CLD_EXITED)
2109 f = SOCKET_FAILURE_EXIT_CODE;
2110 else if (code == CLD_KILLED)
2111 f = SOCKET_FAILURE_SIGNAL;
2112 else if (code == CLD_DUMPED)
2113 f = SOCKET_FAILURE_CORE_DUMP;
2115 assert_not_reached("Unknown code");
2117 if (s->control_command) {
2118 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2120 if (s->control_command->ignore)
2124 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2126 "%s control process exited, code=%s status=%i",
2127 u->id, sigchld_code_to_string(code), status);
2129 if (f != SOCKET_SUCCESS)
2132 if (s->control_command &&
2133 s->control_command->command_next &&
2134 f == SOCKET_SUCCESS) {
2136 log_debug_unit(u->id,
2137 "%s running next command for state %s",
2138 u->id, socket_state_to_string(s->state));
2141 s->control_command = NULL;
2142 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2144 /* No further commands for this step, so let's figure
2145 * out what to do next */
2147 log_debug_unit(u->id,
2148 "%s got final SIGCHLD for state %s",
2149 u->id, socket_state_to_string(s->state));
2153 case SOCKET_START_PRE:
2154 if (f == SOCKET_SUCCESS)
2155 socket_enter_start_post(s);
2157 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2160 case SOCKET_START_POST:
2161 if (f == SOCKET_SUCCESS)
2162 socket_enter_listening(s);
2164 socket_enter_stop_pre(s, f);
2167 case SOCKET_STOP_PRE:
2168 case SOCKET_STOP_PRE_SIGTERM:
2169 case SOCKET_STOP_PRE_SIGKILL:
2170 socket_enter_stop_post(s, f);
2173 case SOCKET_STOP_POST:
2174 case SOCKET_FINAL_SIGTERM:
2175 case SOCKET_FINAL_SIGKILL:
2176 socket_enter_dead(s, f);
2180 assert_not_reached("Uh, control process died at wrong time.");
2184 /* Notify clients about changed exit status */
2185 unit_add_to_dbus_queue(u);
2188 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2189 Socket *s = SOCKET(userdata);
2192 assert(s->timer_event_source == source);
2196 case SOCKET_START_PRE:
2197 log_warning_unit(UNIT(s)->id,
2198 "%s starting timed out. Terminating.", UNIT(s)->id);
2199 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2202 case SOCKET_START_POST:
2203 log_warning_unit(UNIT(s)->id,
2204 "%s starting timed out. Stopping.", UNIT(s)->id);
2205 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2208 case SOCKET_STOP_PRE:
2209 log_warning_unit(UNIT(s)->id,
2210 "%s stopping timed out. Terminating.", UNIT(s)->id);
2211 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2214 case SOCKET_STOP_PRE_SIGTERM:
2215 if (s->kill_context.send_sigkill) {
2216 log_warning_unit(UNIT(s)->id,
2217 "%s stopping timed out. Killing.", UNIT(s)->id);
2218 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2220 log_warning_unit(UNIT(s)->id,
2221 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2223 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2227 case SOCKET_STOP_PRE_SIGKILL:
2228 log_warning_unit(UNIT(s)->id,
2229 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2230 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2233 case SOCKET_STOP_POST:
2234 log_warning_unit(UNIT(s)->id,
2235 "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2236 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2239 case SOCKET_FINAL_SIGTERM:
2240 if (s->kill_context.send_sigkill) {
2241 log_warning_unit(UNIT(s)->id,
2242 "%s stopping timed out (2). Killing.", UNIT(s)->id);
2243 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2245 log_warning_unit(UNIT(s)->id,
2246 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2248 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2252 case SOCKET_FINAL_SIGKILL:
2253 log_warning_unit(UNIT(s)->id,
2254 "%s still around after SIGKILL (2). Entering failed mode.",
2256 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2260 assert_not_reached("Timeout at wrong time.");
2266 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2275 /* Called from the service code for requesting our fds */
2278 LIST_FOREACH(port, p, s->ports)
2288 if (!(rfds = new(int, rn_fds)))
2292 LIST_FOREACH(port, p, s->ports)
2296 assert(k == rn_fds);
2304 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2307 /* The service is dead. Dang!
2309 * This is strictly for one-instance-for-all-connections
2312 if (s->state == SOCKET_RUNNING) {
2313 log_debug_unit(UNIT(s)->id,
2314 "%s got notified about service death (failed permanently: %s)",
2315 UNIT(s)->id, yes_no(failed_permanent));
2316 if (failed_permanent)
2317 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2319 socket_enter_listening(s);
2323 void socket_connection_unref(Socket *s) {
2326 /* The service is dead. Yay!
2328 * This is strictly for one-instance-per-connection
2331 assert(s->n_connections > 0);
2334 log_debug_unit(UNIT(s)->id,
2335 "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2338 static void socket_reset_failed(Unit *u) {
2339 Socket *s = SOCKET(u);
2343 if (s->state == SOCKET_FAILED)
2344 socket_set_state(s, SOCKET_DEAD);
2346 s->result = SOCKET_SUCCESS;
2349 static void socket_trigger_notify(Unit *u, Unit *other) {
2350 Socket *s = SOCKET(u);
2351 Service *se = SERVICE(other);
2356 /* Don't propagate state changes from the service if we are
2357 already down or accepting connections */
2358 if ((s->state != SOCKET_RUNNING &&
2359 s->state != SOCKET_LISTENING) ||
2363 if (other->load_state != UNIT_LOADED ||
2364 other->type != UNIT_SERVICE)
2367 if (se->state == SERVICE_FAILED)
2368 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2370 if (se->state == SERVICE_DEAD ||
2371 se->state == SERVICE_STOP ||
2372 se->state == SERVICE_STOP_SIGTERM ||
2373 se->state == SERVICE_STOP_SIGKILL ||
2374 se->state == SERVICE_STOP_POST ||
2375 se->state == SERVICE_FINAL_SIGTERM ||
2376 se->state == SERVICE_FINAL_SIGKILL ||
2377 se->state == SERVICE_AUTO_RESTART)
2378 socket_notify_service_dead(s, false);
2380 if (se->state == SERVICE_RUNNING)
2381 socket_set_state(s, SOCKET_RUNNING);
2384 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2385 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2388 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2389 [SOCKET_DEAD] = "dead",
2390 [SOCKET_START_PRE] = "start-pre",
2391 [SOCKET_START_POST] = "start-post",
2392 [SOCKET_LISTENING] = "listening",
2393 [SOCKET_RUNNING] = "running",
2394 [SOCKET_STOP_PRE] = "stop-pre",
2395 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2396 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2397 [SOCKET_STOP_POST] = "stop-post",
2398 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2399 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2400 [SOCKET_FAILED] = "failed"
2403 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2405 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2406 [SOCKET_EXEC_START_PRE] = "StartPre",
2407 [SOCKET_EXEC_START_POST] = "StartPost",
2408 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2409 [SOCKET_EXEC_STOP_POST] = "StopPost"
2412 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2414 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2415 [SOCKET_SUCCESS] = "success",
2416 [SOCKET_FAILURE_RESOURCES] = "resources",
2417 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2418 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2419 [SOCKET_FAILURE_SIGNAL] = "signal",
2420 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2421 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2424 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2426 const UnitVTable socket_vtable = {
2427 .object_size = sizeof(Socket),
2428 .exec_context_offset = offsetof(Socket, exec_context),
2429 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2430 .kill_context_offset = offsetof(Socket, kill_context),
2436 .private_section = "Socket",
2438 .init = socket_init,
2439 .done = socket_done,
2440 .load = socket_load,
2442 .coldplug = socket_coldplug,
2444 .dump = socket_dump,
2446 .start = socket_start,
2447 .stop = socket_stop,
2449 .kill = socket_kill,
2451 .serialize = socket_serialize,
2452 .deserialize_item = socket_deserialize_item,
2453 .distribute_fds = socket_distribute_fds,
2455 .active_state = socket_active_state,
2456 .sub_state_to_string = socket_sub_state_to_string,
2458 .check_gc = socket_check_gc,
2460 .sigchld_event = socket_sigchld_event,
2462 .trigger_notify = socket_trigger_notify,
2464 .reset_failed = socket_reset_failed,
2466 .bus_interface = "org.freedesktop.systemd1.Socket",
2467 .bus_vtable = bus_socket_vtable,
2468 .bus_changing_properties = bus_socket_changing_properties,
2469 .bus_set_property = bus_socket_set_property,
2470 .bus_commit_properties = bus_socket_commit_properties,
2472 .status_message_formats = {
2473 /*.starting_stopping = {
2474 [0] = "Starting socket %s...",
2475 [1] = "Stopping socket %s...",
2477 .finished_start_job = {
2478 [JOB_DONE] = "Listening on %s.",
2479 [JOB_FAILED] = "Failed to listen on %s.",
2480 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2481 [JOB_TIMEOUT] = "Timed out starting %s.",
2483 .finished_stop_job = {
2484 [JOB_DONE] = "Closed %s.",
2485 [JOB_FAILED] = "Failed stopping %s.",
2486 [JOB_TIMEOUT] = "Timed out stopping %s.",