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>
38 #include "load-dropin.h"
39 #include "load-fragment.h"
42 #include "path-util.h"
43 #include "unit-name.h"
44 #include "unit-printf.h"
48 #include "exit-status.h"
50 #include "smack-util.h"
52 #include "bus-error.h"
53 #include "dbus-socket.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 cgroup_context_done(&s->cgroup_context);
138 exec_context_done(&s->exec_context);
139 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
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_add_mount_links(Socket *s) {
252 LIST_FOREACH(port, p, s->ports) {
253 const char *path = NULL;
255 if (p->type == SOCKET_SOCKET)
256 path = socket_address_get_path(&p->address);
257 else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL)
263 r = unit_require_mounts_for(UNIT(s), path);
271 static int socket_add_device_link(Socket *s) {
276 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
279 t = strappenda("/sys/subsystem/net/devices/", s->bind_to_device);
280 return unit_add_node_link(UNIT(s), t, false);
283 static int socket_add_default_dependencies(Socket *s) {
287 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
291 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
292 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
297 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
300 _pure_ static bool socket_has_exec(Socket *s) {
304 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
305 if (s->exec_command[i])
311 static int socket_add_extras(Socket *s) {
317 if (have_non_accept_socket(s)) {
319 if (!UNIT_DEREF(s->service)) {
322 r = unit_load_related_unit(u, ".service", &x);
326 unit_ref_set(&s->service, x);
329 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
334 r = socket_add_mount_links(s);
338 r = socket_add_device_link(s);
342 r = unit_exec_context_defaults(u, &s->exec_context);
346 if (socket_has_exec(s)) {
347 r = unit_add_exec_dependencies(u, &s->exec_context);
351 r = unit_add_default_slice(u);
356 if (u->default_dependencies) {
357 r = socket_add_default_dependencies(s);
365 static int socket_verify(Socket *s) {
368 if (UNIT(s)->load_state != UNIT_LOADED)
372 log_error_unit(UNIT(s)->id, "%s lacks Listen setting. Refusing.", UNIT(s)->id);
376 if (s->accept && have_non_accept_socket(s)) {
377 log_error_unit(UNIT(s)->id, "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
382 if (s->accept && s->max_connections <= 0) {
383 log_error_unit(UNIT(s)->id, "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
387 if (s->accept && UNIT_DEREF(s->service)) {
388 log_error_unit(UNIT(s)->id, "Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
392 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
393 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
400 static int socket_load(Unit *u) {
401 Socket *s = SOCKET(u);
405 assert(u->load_state == UNIT_STUB);
407 r = unit_load_fragment_and_dropin(u);
411 if (u->load_state == UNIT_LOADED) {
412 /* This is a new unit? Then let's add in some extras */
413 r = socket_add_extras(s);
418 return socket_verify(s);
421 _const_ static const char* listen_lookup(int family, int type) {
423 if (family == AF_NETLINK)
424 return "ListenNetlink";
426 if (type == SOCK_STREAM)
427 return "ListenStream";
428 else if (type == SOCK_DGRAM)
429 return "ListenDatagram";
430 else if (type == SOCK_SEQPACKET)
431 return "ListenSequentialPacket";
433 assert_not_reached("Unknown socket type");
437 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
439 Socket *s = SOCKET(u);
446 prefix2 = strappenda(prefix, "\t");
449 "%sSocket State: %s\n"
451 "%sBindIPv6Only: %s\n"
453 "%sSocketMode: %04o\n"
454 "%sDirectoryMode: %04o\n"
457 "%sTransparent: %s\n"
459 "%sPassCredentials: %s\n"
460 "%sPassSecurity: %s\n"
461 "%sTCPCongestion: %s\n",
462 prefix, socket_state_to_string(s->state),
463 prefix, socket_result_to_string(s->result),
464 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
466 prefix, s->socket_mode,
467 prefix, s->directory_mode,
468 prefix, yes_no(s->keep_alive),
469 prefix, yes_no(s->free_bind),
470 prefix, yes_no(s->transparent),
471 prefix, yes_no(s->broadcast),
472 prefix, yes_no(s->pass_cred),
473 prefix, yes_no(s->pass_sec),
474 prefix, strna(s->tcp_congestion));
476 if (s->control_pid > 0)
478 "%sControl PID: %lu\n",
479 prefix, (unsigned long) s->control_pid);
481 if (s->bind_to_device)
483 "%sBindToDevice: %s\n",
484 prefix, s->bind_to_device);
489 "%sNConnections: %u\n"
490 "%sMaxConnections: %u\n",
491 prefix, s->n_accepted,
492 prefix, s->n_connections,
493 prefix, s->max_connections);
495 if (s->priority >= 0)
498 prefix, s->priority);
500 if (s->receive_buffer > 0)
502 "%sReceiveBuffer: %zu\n",
503 prefix, s->receive_buffer);
505 if (s->send_buffer > 0)
507 "%sSendBuffer: %zu\n",
508 prefix, s->send_buffer);
520 if (s->pipe_size > 0)
523 prefix, s->pipe_size);
530 if (s->mq_maxmsg > 0)
532 "%sMessageQueueMaxMessages: %li\n",
533 prefix, s->mq_maxmsg);
535 if (s->mq_msgsize > 0)
537 "%sMessageQueueMessageSize: %li\n",
538 prefix, s->mq_msgsize);
543 prefix, yes_no(s->reuse_port));
547 "%sSmackLabel: %s\n",
552 "%sSmackLabelIPIn: %s\n",
553 prefix, s->smack_ip_in);
557 "%sSmackLabelIPOut: %s\n",
558 prefix, s->smack_ip_out);
560 LIST_FOREACH(port, p, s->ports) {
562 if (p->type == SOCKET_SOCKET) {
567 if ((r = socket_address_print(&p->address, &k)) < 0)
572 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
574 } else if (p->type == SOCKET_SPECIAL)
575 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
576 else if (p->type == SOCKET_MQUEUE)
577 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
579 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
582 exec_context_dump(&s->exec_context, f, prefix);
583 kill_context_dump(&s->kill_context, f, prefix);
585 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
586 if (!s->exec_command[c])
589 fprintf(f, "%s-> %s:\n",
590 prefix, socket_exec_command_to_string(c));
592 exec_command_dump_list(s->exec_command[c], f, prefix2);
596 static int instance_from_socket(int fd, unsigned nr, char **instance) {
601 struct sockaddr_un un;
602 struct sockaddr_in in;
603 struct sockaddr_in6 in6;
604 struct sockaddr_storage storage;
611 if (getsockname(fd, &local.sa, &l) < 0)
615 if (getpeername(fd, &remote.sa, &l) < 0)
618 switch (local.sa.sa_family) {
622 a = ntohl(local.in.sin_addr.s_addr),
623 b = ntohl(remote.in.sin_addr.s_addr);
626 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
628 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
629 ntohs(local.in.sin_port),
630 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
631 ntohs(remote.in.sin_port)) < 0)
638 static const unsigned char ipv4_prefix[] = {
639 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
642 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
643 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
645 *a = local.in6.sin6_addr.s6_addr+12,
646 *b = remote.in6.sin6_addr.s6_addr+12;
649 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
651 a[0], a[1], a[2], a[3],
652 ntohs(local.in6.sin6_port),
653 b[0], b[1], b[2], b[3],
654 ntohs(remote.in6.sin6_port)) < 0)
657 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
662 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
663 ntohs(local.in6.sin6_port),
664 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
665 ntohs(remote.in6.sin6_port)) < 0)
676 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
682 (unsigned long) ucred.pid,
683 (unsigned long) ucred.uid) < 0)
690 assert_not_reached("Unhandled socket type.");
697 static void socket_close_fds(Socket *s) {
702 LIST_FOREACH(port, p, s->ports) {
704 p->event_source = sd_event_source_unref(p->event_source);
709 close_nointr_nofail(p->fd);
711 /* One little note: we should never delete any sockets
712 * in the file system here! After all some other
713 * process we spawned might still have a reference of
714 * this fd and wants to continue to use it. Therefore
715 * we delete sockets in the file system before we
716 * create a new one, not after we stopped using
723 static void socket_apply_socket_options(Socket *s, int fd) {
728 int b = s->keep_alive;
729 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
730 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
735 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
736 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
741 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
742 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
747 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
748 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
751 if (s->priority >= 0)
752 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
753 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
755 if (s->receive_buffer > 0) {
756 int value = (int) s->receive_buffer;
758 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
760 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
761 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
762 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
765 if (s->send_buffer > 0) {
766 int value = (int) s->send_buffer;
767 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
768 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
769 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
773 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
774 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
777 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
778 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
780 if (s->ip_ttl >= 0) {
783 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
785 if (socket_ipv6_is_supported())
786 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
789 errno = EAFNOSUPPORT;
793 log_warning_unit(UNIT(s)->id,
794 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
797 if (s->tcp_congestion)
798 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
799 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
802 int b = s->reuse_port;
803 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)) < 0)
804 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
808 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
809 log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
812 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
813 log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
816 static void socket_apply_fifo_options(Socket *s, int fd) {
820 if (s->pipe_size > 0)
821 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
822 log_warning_unit(UNIT(s)->id,
826 if (smack_label_fd(fd, s->smack) < 0)
827 log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
830 static int fifo_address_create(
832 mode_t directory_mode,
843 mkdir_parents_label(path, directory_mode);
845 r = label_context_set(path, S_IFIFO);
849 /* Enforce the right access mode for the fifo */
850 old_mask = umask(~ socket_mode);
852 /* Include the original umask in our mask */
853 umask(~socket_mode | old_mask);
855 r = mkfifo(path, socket_mode);
858 if (r < 0 && errno != EEXIST) {
863 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
868 label_context_clear();
870 if (fstat(fd, &st) < 0) {
875 if (!S_ISFIFO(st.st_mode) ||
876 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
877 st.st_uid != getuid() ||
878 st.st_gid != getgid()) {
888 label_context_clear();
891 close_nointr_nofail(fd);
896 static int special_address_create(
906 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
911 if (fstat(fd, &st) < 0) {
916 /* Check whether this is a /proc, /sys or /dev file or char device */
917 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
927 close_nointr_nofail(fd);
932 static int mq_address_create(
942 struct mq_attr _attr, *attr = NULL;
947 if (maxmsg > 0 && msgsize > 0) {
949 _attr.mq_flags = O_NONBLOCK;
950 _attr.mq_maxmsg = maxmsg;
951 _attr.mq_msgsize = msgsize;
955 /* Enforce the right access mode for the mq */
956 old_mask = umask(~ mq_mode);
958 /* Include the original umask in our mask */
959 umask(~mq_mode | old_mask);
961 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
969 if (fstat(fd, &st) < 0) {
974 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
975 st.st_uid != getuid() ||
976 st.st_gid != getgid()) {
987 close_nointr_nofail(fd);
992 static int socket_open_fds(Socket *s) {
996 bool know_label = false;
1000 LIST_FOREACH(port, p, s->ports) {
1005 if (p->type == SOCKET_SOCKET) {
1009 if ((r = socket_instantiate_service(s)) < 0)
1012 if (UNIT_ISSET(s->service) &&
1013 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1014 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1025 r = socket_address_listen(
1027 SOCK_CLOEXEC|SOCK_NONBLOCK,
1040 socket_apply_socket_options(s, p->fd);
1042 } else if (p->type == SOCKET_SPECIAL) {
1044 r = special_address_create(
1050 } else if (p->type == SOCKET_FIFO) {
1052 r = fifo_address_create(
1060 socket_apply_fifo_options(s, p->fd);
1061 } else if (p->type == SOCKET_MQUEUE) {
1063 r = mq_address_create(
1072 assert_not_reached("Unknown port type");
1079 socket_close_fds(s);
1084 static void socket_unwatch_fds(Socket *s) {
1090 LIST_FOREACH(port, p, s->ports) {
1094 if (p->event_source) {
1095 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_OFF);
1097 log_debug_unit(UNIT(s)->id, "Failed to disable event source.");
1102 static int socket_watch_fds(Socket *s) {
1108 LIST_FOREACH(port, p, s->ports) {
1112 if (p->event_source)
1113 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1115 r = sd_event_add_io(UNIT(s)->manager->event, p->fd, EPOLLIN, socket_dispatch_io, p, &p->event_source);
1118 log_warning_unit(UNIT(s)->id, "Failed to watch listening fds: %s", strerror(-r));
1126 socket_unwatch_fds(s);
1130 static void socket_set_state(Socket *s, SocketState state) {
1131 SocketState old_state;
1134 old_state = s->state;
1137 if (state != SOCKET_START_PRE &&
1138 state != SOCKET_START_POST &&
1139 state != SOCKET_STOP_PRE &&
1140 state != SOCKET_STOP_PRE_SIGTERM &&
1141 state != SOCKET_STOP_PRE_SIGKILL &&
1142 state != SOCKET_STOP_POST &&
1143 state != SOCKET_FINAL_SIGTERM &&
1144 state != SOCKET_FINAL_SIGKILL) {
1146 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1147 socket_unwatch_control_pid(s);
1148 s->control_command = NULL;
1149 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1152 if (state != SOCKET_LISTENING)
1153 socket_unwatch_fds(s);
1155 if (state != SOCKET_START_POST &&
1156 state != SOCKET_LISTENING &&
1157 state != SOCKET_RUNNING &&
1158 state != SOCKET_STOP_PRE &&
1159 state != SOCKET_STOP_PRE_SIGTERM &&
1160 state != SOCKET_STOP_PRE_SIGKILL)
1161 socket_close_fds(s);
1163 if (state != old_state)
1164 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s",
1165 UNIT(s)->id, socket_state_to_string(old_state), socket_state_to_string(state));
1167 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1170 static int socket_coldplug(Unit *u) {
1171 Socket *s = SOCKET(u);
1175 assert(s->state == SOCKET_DEAD);
1177 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);
1222 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1231 unit_realize_cgroup(UNIT(s));
1233 r = unit_setup_exec_runtime(UNIT(s));
1237 r = socket_arm_timer(s);
1241 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1249 UNIT(s)->manager->environment,
1253 UNIT(s)->manager->confirm_spawn,
1254 UNIT(s)->manager->cgroup_supported,
1255 UNIT(s)->cgroup_path,
1265 r = unit_watch_pid(UNIT(s), pid);
1267 /* FIXME: we need to do something here */
1275 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1280 static void socket_enter_dead(Socket *s, SocketResult f) {
1283 if (f != SOCKET_SUCCESS)
1286 exec_runtime_destroy(s->exec_runtime);
1287 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1289 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1292 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1294 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1298 if (f != SOCKET_SUCCESS)
1301 socket_unwatch_control_pid(s);
1303 s->control_command_id = SOCKET_EXEC_STOP_POST;
1305 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1306 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1309 socket_set_state(s, SOCKET_STOP_POST);
1311 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1316 log_warning_unit(UNIT(s)->id,
1317 "%s failed to run 'stop-post' task: %s",
1318 UNIT(s)->id, strerror(-r));
1319 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1322 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1327 if (f != SOCKET_SUCCESS)
1330 r = unit_kill_context(
1333 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1341 r = socket_arm_timer(s);
1345 socket_set_state(s, state);
1346 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1347 socket_enter_stop_post(s, SOCKET_SUCCESS);
1349 socket_enter_dead(s, SOCKET_SUCCESS);
1354 log_warning_unit(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1356 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1357 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1359 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1362 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1366 if (f != SOCKET_SUCCESS)
1369 socket_unwatch_control_pid(s);
1371 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1373 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1374 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1377 socket_set_state(s, SOCKET_STOP_PRE);
1379 socket_enter_stop_post(s, SOCKET_SUCCESS);
1384 log_warning_unit(UNIT(s)->id, "%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1385 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1388 static void socket_enter_listening(Socket *s) {
1392 r = socket_watch_fds(s);
1394 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1398 socket_set_state(s, SOCKET_LISTENING);
1402 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1405 static void socket_enter_start_post(Socket *s) {
1409 r = socket_open_fds(s);
1411 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1415 socket_unwatch_control_pid(s);
1417 s->control_command_id = SOCKET_EXEC_START_POST;
1419 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1420 r = socket_spawn(s, s->control_command, &s->control_pid);
1422 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1426 socket_set_state(s, SOCKET_START_POST);
1428 socket_enter_listening(s);
1433 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1436 static void socket_enter_start_pre(Socket *s) {
1440 socket_unwatch_control_pid(s);
1442 s->control_command_id = SOCKET_EXEC_START_PRE;
1444 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1445 r = socket_spawn(s, s->control_command, &s->control_pid);
1449 socket_set_state(s, SOCKET_START_PRE);
1451 socket_enter_start_post(s);
1456 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1457 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1460 static void socket_enter_running(Socket *s, int cfd) {
1461 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1466 /* We don't take connections anymore if we are supposed to
1467 * shut down anyway */
1468 if (unit_stop_pending(UNIT(s))) {
1470 log_debug_unit(UNIT(s)->id, "Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1473 close_nointr_nofail(cfd);
1475 /* Flush all sockets by closing and reopening them */
1476 socket_close_fds(s);
1478 r = socket_open_fds(s);
1480 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1481 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1485 r = socket_watch_fds(s);
1487 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1488 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1498 bool pending = false;
1500 /* If there's already a start pending don't bother to
1502 SET_FOREACH(other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1503 if (unit_active_or_pending(other)) {
1509 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1514 socket_set_state(s, SOCKET_RUNNING);
1516 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1519 if (s->n_connections >= s->max_connections) {
1520 log_warning_unit(UNIT(s)->id, "%s: Too many incoming connections (%u)", UNIT(s)->id, s->n_connections);
1521 close_nointr_nofail(cfd);
1525 r = socket_instantiate_service(s);
1529 r = instance_from_socket(cfd, s->n_accepted, &instance);
1534 /* ENOTCONN is legitimate if TCP RST was received.
1535 * This connection is over, but the socket unit lives on. */
1536 close_nointr_nofail(cfd);
1540 prefix = unit_name_to_prefix(UNIT(s)->id);
1546 name = unit_name_build(prefix, instance, ".service");
1552 r = unit_add_name(UNIT_DEREF(s->service), name);
1556 service = SERVICE(UNIT_DEREF(s->service));
1557 unit_ref_unset(&s->service);
1560 UNIT(service)->no_gc = false;
1562 unit_choose_id(UNIT(service), name);
1564 r = service_set_socket_fd(service, cfd, s);
1569 s->n_connections ++;
1571 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1575 /* Notify clients about changed counters */
1576 unit_add_to_dbus_queue(UNIT(s));
1582 log_warning_unit(UNIT(s)->id, "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1583 UNIT(s)->id, cfd >= 0 ? "template" : "non-template",
1584 bus_error_message(&error, r));
1586 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1589 close_nointr_nofail(cfd);
1592 static void socket_run_next(Socket *s) {
1596 assert(s->control_command);
1597 assert(s->control_command->command_next);
1599 socket_unwatch_control_pid(s);
1601 s->control_command = s->control_command->command_next;
1603 r = socket_spawn(s, s->control_command, &s->control_pid);
1610 log_warning_unit(UNIT(s)->id, "%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1612 if (s->state == SOCKET_START_POST)
1613 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1614 else if (s->state == SOCKET_STOP_POST)
1615 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1617 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1620 static int socket_start(Unit *u) {
1621 Socket *s = SOCKET(u);
1625 /* We cannot fulfill this request right now, try again later
1627 if (s->state == SOCKET_STOP_PRE ||
1628 s->state == SOCKET_STOP_PRE_SIGKILL ||
1629 s->state == SOCKET_STOP_PRE_SIGTERM ||
1630 s->state == SOCKET_STOP_POST ||
1631 s->state == SOCKET_FINAL_SIGTERM ||
1632 s->state == SOCKET_FINAL_SIGKILL)
1635 if (s->state == SOCKET_START_PRE ||
1636 s->state == SOCKET_START_POST)
1639 /* Cannot run this without the service being around */
1640 if (UNIT_ISSET(s->service)) {
1643 service = SERVICE(UNIT_DEREF(s->service));
1645 if (UNIT(service)->load_state != UNIT_LOADED) {
1646 log_error_unit(u->id, "Socket service %s not loaded, refusing.", UNIT(service)->id);
1650 /* If the service is already active we cannot start the
1652 if (service->state != SERVICE_DEAD &&
1653 service->state != SERVICE_FAILED &&
1654 service->state != SERVICE_AUTO_RESTART) {
1655 log_error_unit(u->id, "Socket service %s already active, refusing.", UNIT(service)->id);
1659 #ifdef HAVE_SYSV_COMPAT
1660 if (service->is_sysv) {
1661 log_error_unit(u->id,
1662 "Using SysV services for socket activation is not supported. Refusing.");
1668 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1670 s->result = SOCKET_SUCCESS;
1671 socket_enter_start_pre(s);
1676 static int socket_stop(Unit *u) {
1677 Socket *s = SOCKET(u);
1682 if (s->state == SOCKET_STOP_PRE ||
1683 s->state == SOCKET_STOP_PRE_SIGTERM ||
1684 s->state == SOCKET_STOP_PRE_SIGKILL ||
1685 s->state == SOCKET_STOP_POST ||
1686 s->state == SOCKET_FINAL_SIGTERM ||
1687 s->state == SOCKET_FINAL_SIGKILL)
1690 /* If there's already something running we go directly into
1692 if (s->state == SOCKET_START_PRE ||
1693 s->state == SOCKET_START_POST) {
1694 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1698 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1700 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1704 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1705 Socket *s = SOCKET(u);
1713 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1714 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1715 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1717 if (s->control_pid > 0)
1718 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1720 if (s->control_command_id >= 0)
1721 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1723 LIST_FOREACH(port, p, s->ports) {
1729 copy = fdset_put_dup(fds, p->fd);
1733 if (p->type == SOCKET_SOCKET) {
1734 _cleanup_free_ char *t = NULL;
1736 r = socket_address_print(&p->address, &t);
1740 if (socket_address_family(&p->address) == AF_NETLINK)
1741 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1743 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1745 } else if (p->type == SOCKET_SPECIAL)
1746 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1747 else if (p->type == SOCKET_MQUEUE)
1748 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1750 assert(p->type == SOCKET_FIFO);
1751 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1758 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1759 Socket *s = SOCKET(u);
1765 if (streq(key, "state")) {
1768 state = socket_state_from_string(value);
1770 log_debug_unit(u->id, "Failed to parse state value %s", value);
1772 s->deserialized_state = state;
1773 } else if (streq(key, "result")) {
1776 f = socket_result_from_string(value);
1778 log_debug_unit(u->id, "Failed to parse result value %s", value);
1779 else if (f != SOCKET_SUCCESS)
1782 } else if (streq(key, "n-accepted")) {
1785 if (safe_atou(value, &k) < 0)
1786 log_debug_unit(u->id, "Failed to parse n-accepted value %s", value);
1789 } else if (streq(key, "control-pid")) {
1792 if (parse_pid(value, &pid) < 0)
1793 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1795 s->control_pid = pid;
1796 } else if (streq(key, "control-command")) {
1797 SocketExecCommand id;
1799 id = socket_exec_command_from_string(value);
1801 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1803 s->control_command_id = id;
1804 s->control_command = s->exec_command[id];
1806 } else if (streq(key, "fifo")) {
1810 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1811 log_debug_unit(u->id, "Failed to parse fifo value %s", value);
1814 LIST_FOREACH(port, p, s->ports)
1815 if (p->type == SOCKET_FIFO &&
1816 streq_ptr(p->path, value+skip))
1821 close_nointr_nofail(p->fd);
1822 p->fd = fdset_remove(fds, fd);
1826 } else if (streq(key, "special")) {
1830 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1831 log_debug_unit(u->id, "Failed to parse special value %s", value);
1834 LIST_FOREACH(port, p, s->ports)
1835 if (p->type == SOCKET_SPECIAL &&
1836 streq_ptr(p->path, value+skip))
1841 close_nointr_nofail(p->fd);
1842 p->fd = fdset_remove(fds, fd);
1846 } else if (streq(key, "mqueue")) {
1850 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1851 log_debug_unit(u->id, "Failed to parse mqueue value %s", value);
1854 LIST_FOREACH(port, p, s->ports)
1855 if (p->type == SOCKET_MQUEUE &&
1856 streq_ptr(p->path, value+skip))
1861 close_nointr_nofail(p->fd);
1862 p->fd = fdset_remove(fds, fd);
1866 } else if (streq(key, "socket")) {
1867 int fd, type, skip = 0;
1870 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1871 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1874 LIST_FOREACH(port, p, s->ports)
1875 if (socket_address_is(&p->address, value+skip, type))
1880 close_nointr_nofail(p->fd);
1881 p->fd = fdset_remove(fds, fd);
1885 } else if (streq(key, "netlink")) {
1889 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1890 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1893 LIST_FOREACH(port, p, s->ports)
1894 if (socket_address_is_netlink(&p->address, value+skip))
1899 close_nointr_nofail(p->fd);
1900 p->fd = fdset_remove(fds, fd);
1904 log_debug_unit(UNIT(s)->id, "Unknown serialization key '%s'", key);
1909 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1910 Socket *s = SOCKET(u);
1915 LIST_FOREACH(port, p, s->ports) {
1919 if (p->type != SOCKET_SOCKET)
1925 FDSET_FOREACH(fd, fds, i) {
1926 if (socket_address_matches_fd(&p->address, fd)) {
1927 p->fd = fdset_remove(fds, fd);
1928 s->deserialized_state = SOCKET_LISTENING;
1937 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1940 return state_translation_table[SOCKET(u)->state];
1943 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1946 return socket_state_to_string(SOCKET(u)->state);
1949 const char* socket_port_type_to_string(SocketPort *p) {
1957 switch (p->address.type) {
1965 case SOCK_SEQPACKET:
1966 return "SequentialPacket";
1969 if (socket_address_family(&p->address) == AF_NETLINK)
1976 case SOCKET_SPECIAL:
1980 return "MessageQueue";
1990 _pure_ static bool socket_check_gc(Unit *u) {
1991 Socket *s = SOCKET(u);
1995 return s->n_connections > 0;
1998 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1999 SocketPort *p = userdata;
2005 if (p->socket->state != SOCKET_LISTENING)
2008 log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
2010 if (revents != EPOLLIN) {
2012 if (revents & EPOLLHUP)
2013 log_error_unit(UNIT(p->socket)->id, "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
2014 UNIT(p->socket)->id);
2016 log_error_unit(UNIT(p->socket)->id, "%s: Got unexpected poll event (0x%x) on socket.",
2017 UNIT(p->socket)->id, revents);
2022 if (p->socket->accept &&
2023 p->type == SOCKET_SOCKET &&
2024 socket_address_can_accept(&p->address)) {
2028 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2034 log_error_unit(UNIT(p->socket)->id,
2035 "Failed to accept socket: %m");
2042 socket_apply_socket_options(p->socket, cfd);
2045 socket_enter_running(p->socket, cfd);
2049 socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2053 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2054 Socket *s = SOCKET(u);
2060 if (pid != s->control_pid)
2065 if (is_clean_exit(code, status, NULL))
2067 else if (code == CLD_EXITED)
2068 f = SOCKET_FAILURE_EXIT_CODE;
2069 else if (code == CLD_KILLED)
2070 f = SOCKET_FAILURE_SIGNAL;
2071 else if (code == CLD_DUMPED)
2072 f = SOCKET_FAILURE_CORE_DUMP;
2074 assert_not_reached("Unknown code");
2076 if (s->control_command) {
2077 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2079 if (s->control_command->ignore)
2083 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2085 "%s control process exited, code=%s status=%i",
2086 u->id, sigchld_code_to_string(code), status);
2088 if (f != SOCKET_SUCCESS)
2091 if (s->control_command &&
2092 s->control_command->command_next &&
2093 f == SOCKET_SUCCESS) {
2095 log_debug_unit(u->id,
2096 "%s running next command for state %s",
2097 u->id, socket_state_to_string(s->state));
2100 s->control_command = NULL;
2101 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2103 /* No further commands for this step, so let's figure
2104 * out what to do next */
2106 log_debug_unit(u->id,
2107 "%s got final SIGCHLD for state %s",
2108 u->id, socket_state_to_string(s->state));
2112 case SOCKET_START_PRE:
2113 if (f == SOCKET_SUCCESS)
2114 socket_enter_start_post(s);
2116 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2119 case SOCKET_START_POST:
2120 if (f == SOCKET_SUCCESS)
2121 socket_enter_listening(s);
2123 socket_enter_stop_pre(s, f);
2126 case SOCKET_STOP_PRE:
2127 case SOCKET_STOP_PRE_SIGTERM:
2128 case SOCKET_STOP_PRE_SIGKILL:
2129 socket_enter_stop_post(s, f);
2132 case SOCKET_STOP_POST:
2133 case SOCKET_FINAL_SIGTERM:
2134 case SOCKET_FINAL_SIGKILL:
2135 socket_enter_dead(s, f);
2139 assert_not_reached("Uh, control process died at wrong time.");
2143 /* Notify clients about changed exit status */
2144 unit_add_to_dbus_queue(u);
2147 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2148 Socket *s = SOCKET(userdata);
2151 assert(s->timer_event_source == source);
2155 case SOCKET_START_PRE:
2156 log_warning_unit(UNIT(s)->id,
2157 "%s starting timed out. Terminating.", UNIT(s)->id);
2158 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2161 case SOCKET_START_POST:
2162 log_warning_unit(UNIT(s)->id,
2163 "%s starting timed out. Stopping.", UNIT(s)->id);
2164 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2167 case SOCKET_STOP_PRE:
2168 log_warning_unit(UNIT(s)->id,
2169 "%s stopping timed out. Terminating.", UNIT(s)->id);
2170 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2173 case SOCKET_STOP_PRE_SIGTERM:
2174 if (s->kill_context.send_sigkill) {
2175 log_warning_unit(UNIT(s)->id,
2176 "%s stopping timed out. Killing.", UNIT(s)->id);
2177 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2179 log_warning_unit(UNIT(s)->id,
2180 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2182 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2186 case SOCKET_STOP_PRE_SIGKILL:
2187 log_warning_unit(UNIT(s)->id,
2188 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2189 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2192 case SOCKET_STOP_POST:
2193 log_warning_unit(UNIT(s)->id,
2194 "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2195 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2198 case SOCKET_FINAL_SIGTERM:
2199 if (s->kill_context.send_sigkill) {
2200 log_warning_unit(UNIT(s)->id,
2201 "%s stopping timed out (2). Killing.", UNIT(s)->id);
2202 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2204 log_warning_unit(UNIT(s)->id,
2205 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2207 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2211 case SOCKET_FINAL_SIGKILL:
2212 log_warning_unit(UNIT(s)->id,
2213 "%s still around after SIGKILL (2). Entering failed mode.",
2215 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2219 assert_not_reached("Timeout at wrong time.");
2225 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2234 /* Called from the service code for requesting our fds */
2237 LIST_FOREACH(port, p, s->ports)
2247 if (!(rfds = new(int, rn_fds)))
2251 LIST_FOREACH(port, p, s->ports)
2255 assert(k == rn_fds);
2263 static void socket_reset_failed(Unit *u) {
2264 Socket *s = SOCKET(u);
2268 if (s->state == SOCKET_FAILED)
2269 socket_set_state(s, SOCKET_DEAD);
2271 s->result = SOCKET_SUCCESS;
2274 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2277 /* The service is dead. Dang!
2279 * This is strictly for one-instance-for-all-connections
2282 if (s->state == SOCKET_RUNNING) {
2283 log_debug_unit(UNIT(s)->id, "%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2284 if (failed_permanent)
2285 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2287 socket_enter_listening(s);
2291 void socket_connection_unref(Socket *s) {
2294 /* The service is dead. Yay!
2296 * This is strictly for one-instance-per-connection
2299 assert(s->n_connections > 0);
2302 log_debug_unit(UNIT(s)->id, "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2305 static void socket_trigger_notify(Unit *u, Unit *other) {
2306 Socket *s = SOCKET(u);
2312 /* Don't propagate state changes from the service if we are
2313 already down or accepting connections */
2314 if ((s->state != SOCKET_RUNNING &&
2315 s->state != SOCKET_LISTENING) ||
2319 if (other->load_state != UNIT_LOADED ||
2320 other->type != UNIT_SERVICE)
2323 se = SERVICE(other);
2325 if (se->state == SERVICE_FAILED)
2326 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2328 if (se->state == SERVICE_DEAD ||
2329 se->state == SERVICE_STOP ||
2330 se->state == SERVICE_STOP_SIGTERM ||
2331 se->state == SERVICE_STOP_SIGKILL ||
2332 se->state == SERVICE_STOP_POST ||
2333 se->state == SERVICE_FINAL_SIGTERM ||
2334 se->state == SERVICE_FINAL_SIGKILL ||
2335 se->state == SERVICE_AUTO_RESTART)
2336 socket_notify_service_dead(s, false);
2338 if (se->state == SERVICE_RUNNING)
2339 socket_set_state(s, SOCKET_RUNNING);
2342 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2343 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2346 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2347 [SOCKET_DEAD] = "dead",
2348 [SOCKET_START_PRE] = "start-pre",
2349 [SOCKET_START_POST] = "start-post",
2350 [SOCKET_LISTENING] = "listening",
2351 [SOCKET_RUNNING] = "running",
2352 [SOCKET_STOP_PRE] = "stop-pre",
2353 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2354 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2355 [SOCKET_STOP_POST] = "stop-post",
2356 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2357 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2358 [SOCKET_FAILED] = "failed"
2361 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2363 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2364 [SOCKET_EXEC_START_PRE] = "StartPre",
2365 [SOCKET_EXEC_START_POST] = "StartPost",
2366 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2367 [SOCKET_EXEC_STOP_POST] = "StopPost"
2370 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2372 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2373 [SOCKET_SUCCESS] = "success",
2374 [SOCKET_FAILURE_RESOURCES] = "resources",
2375 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2376 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2377 [SOCKET_FAILURE_SIGNAL] = "signal",
2378 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2379 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2382 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2384 const UnitVTable socket_vtable = {
2385 .object_size = sizeof(Socket),
2386 .exec_context_offset = offsetof(Socket, exec_context),
2387 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2388 .kill_context_offset = offsetof(Socket, kill_context),
2389 .exec_runtime_offset = offsetof(Socket, exec_runtime),
2395 .private_section = "Socket",
2397 .init = socket_init,
2398 .done = socket_done,
2399 .load = socket_load,
2401 .coldplug = socket_coldplug,
2403 .dump = socket_dump,
2405 .start = socket_start,
2406 .stop = socket_stop,
2408 .kill = socket_kill,
2410 .serialize = socket_serialize,
2411 .deserialize_item = socket_deserialize_item,
2412 .distribute_fds = socket_distribute_fds,
2414 .active_state = socket_active_state,
2415 .sub_state_to_string = socket_sub_state_to_string,
2417 .check_gc = socket_check_gc,
2419 .sigchld_event = socket_sigchld_event,
2421 .trigger_notify = socket_trigger_notify,
2423 .reset_failed = socket_reset_failed,
2425 .bus_interface = "org.freedesktop.systemd1.Socket",
2426 .bus_vtable = bus_socket_vtable,
2427 .bus_changing_properties = bus_socket_changing_properties,
2428 .bus_set_property = bus_socket_set_property,
2429 .bus_commit_properties = bus_socket_commit_properties,
2431 .status_message_formats = {
2432 /*.starting_stopping = {
2433 [0] = "Starting socket %s...",
2434 [1] = "Stopping socket %s...",
2436 .finished_start_job = {
2437 [JOB_DONE] = "Listening on %s.",
2438 [JOB_FAILED] = "Failed to listen on %s.",
2439 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2440 [JOB_TIMEOUT] = "Timed out starting %s.",
2442 .finished_stop_job = {
2443 [JOB_DONE] = "Closed %s.",
2444 [JOB_FAILED] = "Failed stopping %s.",
2445 [JOB_TIMEOUT] = "Timed out stopping %s.",