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 unit_cgroup_context_init_defaults(u, &s->cgroup_context);
101 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
104 static void socket_unwatch_control_pid(Socket *s) {
107 if (s->control_pid <= 0)
110 unit_unwatch_pid(UNIT(s), s->control_pid);
114 void socket_free_ports(Socket *s) {
119 while ((p = s->ports)) {
120 LIST_REMOVE(port, s->ports, p);
122 sd_event_source_unref(p->event_source);
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, &s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec, 0, socket_dispatch_timer, s);
181 static int socket_instantiate_service(Socket *s) {
182 _cleanup_free_ char *prefix = NULL;
183 _cleanup_free_ char *name = NULL;
189 /* This fills in s->service if it isn't filled in yet. For
190 * Accept=yes sockets we create the next connection service
191 * here. For Accept=no this is mostly a NOP since the service
192 * is figured out at load time anyway. */
194 if (UNIT_DEREF(s->service))
199 prefix = unit_name_to_prefix(UNIT(s)->id);
203 if (asprintf(&name, "%s@%u.service", prefix, s->n_accepted) < 0)
206 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
210 #ifdef HAVE_SYSV_COMPAT
211 if (SERVICE(u)->is_sysv) {
212 log_error("Using SysV services for socket activation is not supported. Refusing.");
218 unit_ref_set(&s->service, u);
220 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
223 static bool have_non_accept_socket(Socket *s) {
231 LIST_FOREACH(port, p, s->ports) {
233 if (p->type != SOCKET_SOCKET)
236 if (!socket_address_can_accept(&p->address))
243 static int socket_add_mount_links(Socket *s) {
249 LIST_FOREACH(port, p, s->ports) {
250 const char *path = NULL;
252 if (p->type == SOCKET_SOCKET)
253 path = socket_address_get_path(&p->address);
254 else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL)
260 r = unit_require_mounts_for(UNIT(s), path);
268 static int socket_add_device_link(Socket *s) {
273 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
276 t = strappenda("/sys/subsystem/net/devices/", s->bind_to_device);
277 return unit_add_node_link(UNIT(s), t, false);
280 static int socket_add_default_dependencies(Socket *s) {
284 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
288 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
289 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
294 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
297 _pure_ static bool socket_has_exec(Socket *s) {
301 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
302 if (s->exec_command[i])
308 static int socket_add_extras(Socket *s) {
314 if (have_non_accept_socket(s)) {
316 if (!UNIT_DEREF(s->service)) {
319 r = unit_load_related_unit(u, ".service", &x);
323 unit_ref_set(&s->service, x);
326 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
331 r = socket_add_mount_links(s);
335 r = socket_add_device_link(s);
339 r = unit_exec_context_patch_defaults(u, &s->exec_context);
343 if (socket_has_exec(s)) {
344 r = unit_add_exec_dependencies(u, &s->exec_context);
348 r = unit_add_default_slice(u);
353 if (u->default_dependencies) {
354 r = socket_add_default_dependencies(s);
362 static int socket_verify(Socket *s) {
365 if (UNIT(s)->load_state != UNIT_LOADED)
369 log_error_unit(UNIT(s)->id, "%s lacks Listen setting. Refusing.", UNIT(s)->id);
373 if (s->accept && have_non_accept_socket(s)) {
374 log_error_unit(UNIT(s)->id, "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
379 if (s->accept && s->max_connections <= 0) {
380 log_error_unit(UNIT(s)->id, "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
384 if (s->accept && UNIT_DEREF(s->service)) {
385 log_error_unit(UNIT(s)->id, "Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
389 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
390 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
397 static int socket_load(Unit *u) {
398 Socket *s = SOCKET(u);
402 assert(u->load_state == UNIT_STUB);
404 r = unit_load_fragment_and_dropin(u);
408 if (u->load_state == UNIT_LOADED) {
409 /* This is a new unit? Then let's add in some extras */
410 r = socket_add_extras(s);
415 return socket_verify(s);
418 _const_ static const char* listen_lookup(int family, int type) {
420 if (family == AF_NETLINK)
421 return "ListenNetlink";
423 if (type == SOCK_STREAM)
424 return "ListenStream";
425 else if (type == SOCK_DGRAM)
426 return "ListenDatagram";
427 else if (type == SOCK_SEQPACKET)
428 return "ListenSequentialPacket";
430 assert_not_reached("Unknown socket type");
434 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
436 Socket *s = SOCKET(u);
443 prefix2 = strappenda(prefix, "\t");
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);
593 static int instance_from_socket(int fd, unsigned nr, char **instance) {
596 union sockaddr_union local, remote;
602 if (getsockname(fd, &local.sa, &l) < 0)
606 if (getpeername(fd, &remote.sa, &l) < 0)
609 switch (local.sa.sa_family) {
613 a = ntohl(local.in.sin_addr.s_addr),
614 b = ntohl(remote.in.sin_addr.s_addr);
617 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
619 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
620 ntohs(local.in.sin_port),
621 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
622 ntohs(remote.in.sin_port)) < 0)
629 static const unsigned char ipv4_prefix[] = {
630 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
633 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
634 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
636 *a = local.in6.sin6_addr.s6_addr+12,
637 *b = remote.in6.sin6_addr.s6_addr+12;
640 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
642 a[0], a[1], a[2], a[3],
643 ntohs(local.in6.sin6_port),
644 b[0], b[1], b[2], b[3],
645 ntohs(remote.in6.sin6_port)) < 0)
648 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
653 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
654 ntohs(local.in6.sin6_port),
655 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
656 ntohs(remote.in6.sin6_port)) < 0)
667 k = getpeercred(fd, &ucred);
674 (unsigned long) ucred.pid,
675 (unsigned long) ucred.uid) < 0)
682 assert_not_reached("Unhandled socket type.");
689 static void socket_close_fds(Socket *s) {
694 LIST_FOREACH(port, p, s->ports) {
696 p->event_source = sd_event_source_unref(p->event_source);
701 p->fd = safe_close(p->fd);
703 /* One little note: we should never delete any sockets
704 * in the file system here! After all some other
705 * process we spawned might still have a reference of
706 * this fd and wants to continue to use it. Therefore
707 * we delete sockets in the file system before we
708 * create a new one, not after we stopped using
713 static void socket_apply_socket_options(Socket *s, int fd) {
718 int b = s->keep_alive;
719 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
720 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
725 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
726 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
731 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
732 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
737 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
738 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
741 if (s->priority >= 0)
742 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
743 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
745 if (s->receive_buffer > 0) {
746 int value = (int) s->receive_buffer;
748 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
750 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
751 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
752 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
755 if (s->send_buffer > 0) {
756 int value = (int) s->send_buffer;
757 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
758 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
759 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
763 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
764 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
767 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
768 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
770 if (s->ip_ttl >= 0) {
773 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
775 if (socket_ipv6_is_supported())
776 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
779 errno = EAFNOSUPPORT;
783 log_warning_unit(UNIT(s)->id,
784 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
787 if (s->tcp_congestion)
788 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
789 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
792 int b = s->reuse_port;
793 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)) < 0)
794 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
798 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
799 log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
802 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
803 log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
806 static void socket_apply_fifo_options(Socket *s, int fd) {
810 if (s->pipe_size > 0)
811 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
812 log_warning_unit(UNIT(s)->id,
816 if (smack_label_fd(fd, s->smack) < 0)
817 log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
820 static int fifo_address_create(
822 mode_t directory_mode,
833 mkdir_parents_label(path, directory_mode);
835 r = label_context_set(path, S_IFIFO);
839 /* Enforce the right access mode for the fifo */
840 old_mask = umask(~ socket_mode);
842 /* Include the original umask in our mask */
843 umask(~socket_mode | old_mask);
845 r = mkfifo(path, socket_mode);
848 if (r < 0 && errno != EEXIST) {
853 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
858 label_context_clear();
860 if (fstat(fd, &st) < 0) {
865 if (!S_ISFIFO(st.st_mode) ||
866 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
867 st.st_uid != getuid() ||
868 st.st_gid != getgid()) {
878 label_context_clear();
884 static int special_address_create(
894 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
899 if (fstat(fd, &st) < 0) {
904 /* Check whether this is a /proc, /sys or /dev file or char device */
905 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
919 static int mq_address_create(
929 struct mq_attr _attr, *attr = NULL;
934 if (maxmsg > 0 && msgsize > 0) {
936 _attr.mq_flags = O_NONBLOCK;
937 _attr.mq_maxmsg = maxmsg;
938 _attr.mq_msgsize = msgsize;
942 /* Enforce the right access mode for the mq */
943 old_mask = umask(~ mq_mode);
945 /* Include the original umask in our mask */
946 umask(~mq_mode | old_mask);
948 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
956 if (fstat(fd, &st) < 0) {
961 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
962 st.st_uid != getuid() ||
963 st.st_gid != getgid()) {
977 static int socket_open_fds(Socket *s) {
981 bool know_label = false;
985 LIST_FOREACH(port, p, s->ports) {
990 if (p->type == SOCKET_SOCKET) {
994 if ((r = socket_instantiate_service(s)) < 0)
997 if (UNIT_ISSET(s->service) &&
998 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
999 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1010 r = socket_address_listen(
1012 SOCK_CLOEXEC|SOCK_NONBLOCK,
1025 socket_apply_socket_options(s, p->fd);
1027 } else if (p->type == SOCKET_SPECIAL) {
1029 r = special_address_create(
1035 } else if (p->type == SOCKET_FIFO) {
1037 r = fifo_address_create(
1045 socket_apply_fifo_options(s, p->fd);
1046 } else if (p->type == SOCKET_MQUEUE) {
1048 r = mq_address_create(
1057 assert_not_reached("Unknown port type");
1064 socket_close_fds(s);
1069 static void socket_unwatch_fds(Socket *s) {
1075 LIST_FOREACH(port, p, s->ports) {
1079 if (p->event_source) {
1080 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_OFF);
1082 log_debug_unit(UNIT(s)->id, "Failed to disable event source.");
1087 static int socket_watch_fds(Socket *s) {
1093 LIST_FOREACH(port, p, s->ports) {
1097 if (p->event_source)
1098 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1100 r = sd_event_add_io(UNIT(s)->manager->event, &p->event_source, p->fd, EPOLLIN, socket_dispatch_io, p);
1103 log_warning_unit(UNIT(s)->id, "Failed to watch listening fds: %s", strerror(-r));
1111 socket_unwatch_fds(s);
1115 static void socket_set_state(Socket *s, SocketState state) {
1116 SocketState old_state;
1119 old_state = s->state;
1122 if (state != SOCKET_START_PRE &&
1123 state != SOCKET_START_POST &&
1124 state != SOCKET_STOP_PRE &&
1125 state != SOCKET_STOP_PRE_SIGTERM &&
1126 state != SOCKET_STOP_PRE_SIGKILL &&
1127 state != SOCKET_STOP_POST &&
1128 state != SOCKET_FINAL_SIGTERM &&
1129 state != SOCKET_FINAL_SIGKILL) {
1131 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1132 socket_unwatch_control_pid(s);
1133 s->control_command = NULL;
1134 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1137 if (state != SOCKET_LISTENING)
1138 socket_unwatch_fds(s);
1140 if (state != SOCKET_START_POST &&
1141 state != SOCKET_LISTENING &&
1142 state != SOCKET_RUNNING &&
1143 state != SOCKET_STOP_PRE &&
1144 state != SOCKET_STOP_PRE_SIGTERM &&
1145 state != SOCKET_STOP_PRE_SIGKILL)
1146 socket_close_fds(s);
1148 if (state != old_state)
1149 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s",
1150 UNIT(s)->id, socket_state_to_string(old_state), socket_state_to_string(state));
1152 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1155 static int socket_coldplug(Unit *u) {
1156 Socket *s = SOCKET(u);
1160 assert(s->state == SOCKET_DEAD);
1162 if (s->deserialized_state == s->state)
1165 if (s->deserialized_state == SOCKET_START_PRE ||
1166 s->deserialized_state == SOCKET_START_POST ||
1167 s->deserialized_state == SOCKET_STOP_PRE ||
1168 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1169 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1170 s->deserialized_state == SOCKET_STOP_POST ||
1171 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1172 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1174 if (s->control_pid <= 0)
1177 r = unit_watch_pid(UNIT(s), s->control_pid);
1181 r = socket_arm_timer(s);
1186 if (s->deserialized_state == SOCKET_START_POST ||
1187 s->deserialized_state == SOCKET_LISTENING ||
1188 s->deserialized_state == SOCKET_RUNNING ||
1189 s->deserialized_state == SOCKET_STOP_PRE ||
1190 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1191 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL) {
1192 r = socket_open_fds(s);
1197 if (s->deserialized_state == SOCKET_LISTENING) {
1198 r = socket_watch_fds(s);
1203 socket_set_state(s, s->deserialized_state);
1207 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1216 unit_realize_cgroup(UNIT(s));
1218 r = unit_setup_exec_runtime(UNIT(s));
1222 r = socket_arm_timer(s);
1226 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1234 UNIT(s)->manager->environment,
1238 UNIT(s)->manager->confirm_spawn,
1239 UNIT(s)->manager->cgroup_supported,
1240 UNIT(s)->cgroup_path,
1241 manager_get_runtime_prefix(UNIT(s)->manager),
1252 r = unit_watch_pid(UNIT(s), pid);
1254 /* FIXME: we need to do something here */
1262 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1267 static void socket_enter_dead(Socket *s, SocketResult f) {
1270 if (f != SOCKET_SUCCESS)
1273 exec_runtime_destroy(s->exec_runtime);
1274 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1276 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1278 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1281 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1283 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1287 if (f != SOCKET_SUCCESS)
1290 socket_unwatch_control_pid(s);
1292 s->control_command_id = SOCKET_EXEC_STOP_POST;
1294 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1295 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1298 socket_set_state(s, SOCKET_STOP_POST);
1300 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1305 log_warning_unit(UNIT(s)->id,
1306 "%s failed to run 'stop-post' task: %s",
1307 UNIT(s)->id, strerror(-r));
1308 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1311 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1316 if (f != SOCKET_SUCCESS)
1319 r = unit_kill_context(
1322 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1330 r = socket_arm_timer(s);
1334 socket_set_state(s, state);
1335 } else if (state == SOCKET_STOP_PRE_SIGTERM)
1336 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_SUCCESS);
1337 else if (state == SOCKET_STOP_PRE_SIGKILL)
1338 socket_enter_stop_post(s, SOCKET_SUCCESS);
1339 else if (state == SOCKET_FINAL_SIGTERM)
1340 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
1342 socket_enter_dead(s, SOCKET_SUCCESS);
1347 log_warning_unit(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1349 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1350 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1352 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1355 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1359 if (f != SOCKET_SUCCESS)
1362 socket_unwatch_control_pid(s);
1364 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1366 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1367 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1370 socket_set_state(s, SOCKET_STOP_PRE);
1372 socket_enter_stop_post(s, SOCKET_SUCCESS);
1377 log_warning_unit(UNIT(s)->id, "%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1378 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1381 static void socket_enter_listening(Socket *s) {
1385 r = socket_watch_fds(s);
1387 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1391 socket_set_state(s, SOCKET_LISTENING);
1395 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1398 static void socket_enter_start_post(Socket *s) {
1402 r = socket_open_fds(s);
1404 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1408 socket_unwatch_control_pid(s);
1410 s->control_command_id = SOCKET_EXEC_START_POST;
1412 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1413 r = socket_spawn(s, s->control_command, &s->control_pid);
1415 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1419 socket_set_state(s, SOCKET_START_POST);
1421 socket_enter_listening(s);
1426 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1429 static void socket_enter_start_pre(Socket *s) {
1433 socket_unwatch_control_pid(s);
1435 s->control_command_id = SOCKET_EXEC_START_PRE;
1437 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1438 r = socket_spawn(s, s->control_command, &s->control_pid);
1442 socket_set_state(s, SOCKET_START_PRE);
1444 socket_enter_start_post(s);
1449 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1450 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1453 static void socket_enter_running(Socket *s, int cfd) {
1454 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1459 /* We don't take connections anymore if we are supposed to
1460 * shut down anyway */
1461 if (unit_stop_pending(UNIT(s))) {
1463 log_debug_unit(UNIT(s)->id, "Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1468 /* Flush all sockets by closing and reopening them */
1469 socket_close_fds(s);
1471 r = socket_open_fds(s);
1473 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1474 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1478 r = socket_watch_fds(s);
1480 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1481 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1491 bool pending = false;
1493 /* If there's already a start pending don't bother to
1495 SET_FOREACH(other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1496 if (unit_active_or_pending(other)) {
1502 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1507 socket_set_state(s, SOCKET_RUNNING);
1509 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1512 if (s->n_connections >= s->max_connections) {
1513 log_warning_unit(UNIT(s)->id, "%s: Too many incoming connections (%u)", UNIT(s)->id, s->n_connections);
1518 r = socket_instantiate_service(s);
1522 r = instance_from_socket(cfd, s->n_accepted, &instance);
1527 /* ENOTCONN is legitimate if TCP RST was received.
1528 * This connection is over, but the socket unit lives on. */
1533 prefix = unit_name_to_prefix(UNIT(s)->id);
1539 name = unit_name_build(prefix, instance, ".service");
1545 r = unit_add_name(UNIT_DEREF(s->service), name);
1549 service = SERVICE(UNIT_DEREF(s->service));
1550 unit_ref_unset(&s->service);
1553 UNIT(service)->no_gc = false;
1555 unit_choose_id(UNIT(service), name);
1557 r = service_set_socket_fd(service, cfd, s);
1562 s->n_connections ++;
1564 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1568 /* Notify clients about changed counters */
1569 unit_add_to_dbus_queue(UNIT(s));
1575 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",
1576 UNIT(s)->id, cfd >= 0 ? "template" : "non-template",
1577 bus_error_message(&error, r));
1579 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1583 static void socket_run_next(Socket *s) {
1587 assert(s->control_command);
1588 assert(s->control_command->command_next);
1590 socket_unwatch_control_pid(s);
1592 s->control_command = s->control_command->command_next;
1594 r = socket_spawn(s, s->control_command, &s->control_pid);
1601 log_warning_unit(UNIT(s)->id, "%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1603 if (s->state == SOCKET_START_POST)
1604 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1605 else if (s->state == SOCKET_STOP_POST)
1606 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1608 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1611 static int socket_start(Unit *u) {
1612 Socket *s = SOCKET(u);
1616 /* We cannot fulfill this request right now, try again later
1618 if (s->state == SOCKET_STOP_PRE ||
1619 s->state == SOCKET_STOP_PRE_SIGKILL ||
1620 s->state == SOCKET_STOP_PRE_SIGTERM ||
1621 s->state == SOCKET_STOP_POST ||
1622 s->state == SOCKET_FINAL_SIGTERM ||
1623 s->state == SOCKET_FINAL_SIGKILL)
1626 if (s->state == SOCKET_START_PRE ||
1627 s->state == SOCKET_START_POST)
1630 /* Cannot run this without the service being around */
1631 if (UNIT_ISSET(s->service)) {
1634 service = SERVICE(UNIT_DEREF(s->service));
1636 if (UNIT(service)->load_state != UNIT_LOADED) {
1637 log_error_unit(u->id, "Socket service %s not loaded, refusing.", UNIT(service)->id);
1641 /* If the service is already active we cannot start the
1643 if (service->state != SERVICE_DEAD &&
1644 service->state != SERVICE_FAILED &&
1645 service->state != SERVICE_AUTO_RESTART) {
1646 log_error_unit(u->id, "Socket service %s already active, refusing.", UNIT(service)->id);
1650 #ifdef HAVE_SYSV_COMPAT
1651 if (service->is_sysv) {
1652 log_error_unit(u->id,
1653 "Using SysV services for socket activation is not supported. Refusing.");
1659 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1661 s->result = SOCKET_SUCCESS;
1662 socket_enter_start_pre(s);
1667 static int socket_stop(Unit *u) {
1668 Socket *s = SOCKET(u);
1673 if (s->state == SOCKET_STOP_PRE ||
1674 s->state == SOCKET_STOP_PRE_SIGTERM ||
1675 s->state == SOCKET_STOP_PRE_SIGKILL ||
1676 s->state == SOCKET_STOP_POST ||
1677 s->state == SOCKET_FINAL_SIGTERM ||
1678 s->state == SOCKET_FINAL_SIGKILL)
1681 /* If there's already something running we go directly into
1683 if (s->state == SOCKET_START_PRE ||
1684 s->state == SOCKET_START_POST) {
1685 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1689 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1691 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1695 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1696 Socket *s = SOCKET(u);
1704 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1705 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1706 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1708 if (s->control_pid > 0)
1709 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1711 if (s->control_command_id >= 0)
1712 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1714 LIST_FOREACH(port, p, s->ports) {
1720 copy = fdset_put_dup(fds, p->fd);
1724 if (p->type == SOCKET_SOCKET) {
1725 _cleanup_free_ char *t = NULL;
1727 r = socket_address_print(&p->address, &t);
1731 if (socket_address_family(&p->address) == AF_NETLINK)
1732 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1734 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1736 } else if (p->type == SOCKET_SPECIAL)
1737 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1738 else if (p->type == SOCKET_MQUEUE)
1739 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1741 assert(p->type == SOCKET_FIFO);
1742 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1749 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1750 Socket *s = SOCKET(u);
1756 if (streq(key, "state")) {
1759 state = socket_state_from_string(value);
1761 log_debug_unit(u->id, "Failed to parse state value %s", value);
1763 s->deserialized_state = state;
1764 } else if (streq(key, "result")) {
1767 f = socket_result_from_string(value);
1769 log_debug_unit(u->id, "Failed to parse result value %s", value);
1770 else if (f != SOCKET_SUCCESS)
1773 } else if (streq(key, "n-accepted")) {
1776 if (safe_atou(value, &k) < 0)
1777 log_debug_unit(u->id, "Failed to parse n-accepted value %s", value);
1780 } else if (streq(key, "control-pid")) {
1783 if (parse_pid(value, &pid) < 0)
1784 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1786 s->control_pid = pid;
1787 } else if (streq(key, "control-command")) {
1788 SocketExecCommand id;
1790 id = socket_exec_command_from_string(value);
1792 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1794 s->control_command_id = id;
1795 s->control_command = s->exec_command[id];
1797 } else if (streq(key, "fifo")) {
1801 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1802 log_debug_unit(u->id, "Failed to parse fifo value %s", value);
1805 LIST_FOREACH(port, p, s->ports)
1806 if (p->type == SOCKET_FIFO &&
1807 streq_ptr(p->path, value+skip))
1812 p->fd = fdset_remove(fds, fd);
1816 } else if (streq(key, "special")) {
1820 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1821 log_debug_unit(u->id, "Failed to parse special value %s", value);
1824 LIST_FOREACH(port, p, s->ports)
1825 if (p->type == SOCKET_SPECIAL &&
1826 streq_ptr(p->path, value+skip))
1831 p->fd = fdset_remove(fds, fd);
1835 } else if (streq(key, "mqueue")) {
1839 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1840 log_debug_unit(u->id, "Failed to parse mqueue value %s", value);
1843 LIST_FOREACH(port, p, s->ports)
1844 if (p->type == SOCKET_MQUEUE &&
1845 streq_ptr(p->path, value+skip))
1850 p->fd = fdset_remove(fds, fd);
1854 } else if (streq(key, "socket")) {
1855 int fd, type, skip = 0;
1858 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1859 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1862 LIST_FOREACH(port, p, s->ports)
1863 if (socket_address_is(&p->address, value+skip, type))
1868 p->fd = fdset_remove(fds, fd);
1872 } else if (streq(key, "netlink")) {
1876 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1877 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1880 LIST_FOREACH(port, p, s->ports)
1881 if (socket_address_is_netlink(&p->address, value+skip))
1886 p->fd = fdset_remove(fds, fd);
1890 log_debug_unit(UNIT(s)->id, "Unknown serialization key '%s'", key);
1895 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1896 Socket *s = SOCKET(u);
1901 LIST_FOREACH(port, p, s->ports) {
1905 if (p->type != SOCKET_SOCKET)
1911 FDSET_FOREACH(fd, fds, i) {
1912 if (socket_address_matches_fd(&p->address, fd)) {
1913 p->fd = fdset_remove(fds, fd);
1914 s->deserialized_state = SOCKET_LISTENING;
1923 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1926 return state_translation_table[SOCKET(u)->state];
1929 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1932 return socket_state_to_string(SOCKET(u)->state);
1935 const char* socket_port_type_to_string(SocketPort *p) {
1943 switch (p->address.type) {
1951 case SOCK_SEQPACKET:
1952 return "SequentialPacket";
1955 if (socket_address_family(&p->address) == AF_NETLINK)
1962 case SOCKET_SPECIAL:
1966 return "MessageQueue";
1976 _pure_ static bool socket_check_gc(Unit *u) {
1977 Socket *s = SOCKET(u);
1981 return s->n_connections > 0;
1984 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1985 SocketPort *p = userdata;
1991 if (p->socket->state != SOCKET_LISTENING)
1994 log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
1996 if (revents != EPOLLIN) {
1998 if (revents & EPOLLHUP)
1999 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.",
2000 UNIT(p->socket)->id);
2002 log_error_unit(UNIT(p->socket)->id, "%s: Got unexpected poll event (0x%x) on socket.",
2003 UNIT(p->socket)->id, revents);
2008 if (p->socket->accept &&
2009 p->type == SOCKET_SOCKET &&
2010 socket_address_can_accept(&p->address)) {
2014 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2020 log_error_unit(UNIT(p->socket)->id,
2021 "Failed to accept socket: %m");
2028 socket_apply_socket_options(p->socket, cfd);
2031 socket_enter_running(p->socket, cfd);
2035 socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2039 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2040 Socket *s = SOCKET(u);
2046 if (pid != s->control_pid)
2051 if (is_clean_exit(code, status, NULL))
2053 else if (code == CLD_EXITED)
2054 f = SOCKET_FAILURE_EXIT_CODE;
2055 else if (code == CLD_KILLED)
2056 f = SOCKET_FAILURE_SIGNAL;
2057 else if (code == CLD_DUMPED)
2058 f = SOCKET_FAILURE_CORE_DUMP;
2060 assert_not_reached("Unknown code");
2062 if (s->control_command) {
2063 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2065 if (s->control_command->ignore)
2069 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2071 "%s control process exited, code=%s status=%i",
2072 u->id, sigchld_code_to_string(code), status);
2074 if (f != SOCKET_SUCCESS)
2077 if (s->control_command &&
2078 s->control_command->command_next &&
2079 f == SOCKET_SUCCESS) {
2081 log_debug_unit(u->id,
2082 "%s running next command for state %s",
2083 u->id, socket_state_to_string(s->state));
2086 s->control_command = NULL;
2087 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2089 /* No further commands for this step, so let's figure
2090 * out what to do next */
2092 log_debug_unit(u->id,
2093 "%s got final SIGCHLD for state %s",
2094 u->id, socket_state_to_string(s->state));
2098 case SOCKET_START_PRE:
2099 if (f == SOCKET_SUCCESS)
2100 socket_enter_start_post(s);
2102 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2105 case SOCKET_START_POST:
2106 if (f == SOCKET_SUCCESS)
2107 socket_enter_listening(s);
2109 socket_enter_stop_pre(s, f);
2112 case SOCKET_STOP_PRE:
2113 case SOCKET_STOP_PRE_SIGTERM:
2114 case SOCKET_STOP_PRE_SIGKILL:
2115 socket_enter_stop_post(s, f);
2118 case SOCKET_STOP_POST:
2119 case SOCKET_FINAL_SIGTERM:
2120 case SOCKET_FINAL_SIGKILL:
2121 socket_enter_dead(s, f);
2125 assert_not_reached("Uh, control process died at wrong time.");
2129 /* Notify clients about changed exit status */
2130 unit_add_to_dbus_queue(u);
2133 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2134 Socket *s = SOCKET(userdata);
2137 assert(s->timer_event_source == source);
2141 case SOCKET_START_PRE:
2142 log_warning_unit(UNIT(s)->id,
2143 "%s starting timed out. Terminating.", UNIT(s)->id);
2144 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2147 case SOCKET_START_POST:
2148 log_warning_unit(UNIT(s)->id,
2149 "%s starting timed out. Stopping.", UNIT(s)->id);
2150 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2153 case SOCKET_STOP_PRE:
2154 log_warning_unit(UNIT(s)->id,
2155 "%s stopping timed out. Terminating.", UNIT(s)->id);
2156 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2159 case SOCKET_STOP_PRE_SIGTERM:
2160 if (s->kill_context.send_sigkill) {
2161 log_warning_unit(UNIT(s)->id,
2162 "%s stopping timed out. Killing.", UNIT(s)->id);
2163 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2165 log_warning_unit(UNIT(s)->id,
2166 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2168 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2172 case SOCKET_STOP_PRE_SIGKILL:
2173 log_warning_unit(UNIT(s)->id,
2174 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2175 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2178 case SOCKET_STOP_POST:
2179 log_warning_unit(UNIT(s)->id,
2180 "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2181 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2184 case SOCKET_FINAL_SIGTERM:
2185 if (s->kill_context.send_sigkill) {
2186 log_warning_unit(UNIT(s)->id,
2187 "%s stopping timed out (2). Killing.", UNIT(s)->id);
2188 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2190 log_warning_unit(UNIT(s)->id,
2191 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2193 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2197 case SOCKET_FINAL_SIGKILL:
2198 log_warning_unit(UNIT(s)->id,
2199 "%s still around after SIGKILL (2). Entering failed mode.",
2201 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2205 assert_not_reached("Timeout at wrong time.");
2211 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2220 /* Called from the service code for requesting our fds */
2223 LIST_FOREACH(port, p, s->ports)
2233 if (!(rfds = new(int, rn_fds)))
2237 LIST_FOREACH(port, p, s->ports)
2241 assert(k == rn_fds);
2249 static void socket_reset_failed(Unit *u) {
2250 Socket *s = SOCKET(u);
2254 if (s->state == SOCKET_FAILED)
2255 socket_set_state(s, SOCKET_DEAD);
2257 s->result = SOCKET_SUCCESS;
2260 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2263 /* The service is dead. Dang!
2265 * This is strictly for one-instance-for-all-connections
2268 if (s->state == SOCKET_RUNNING) {
2269 log_debug_unit(UNIT(s)->id, "%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2270 if (failed_permanent)
2271 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2273 socket_enter_listening(s);
2277 void socket_connection_unref(Socket *s) {
2280 /* The service is dead. Yay!
2282 * This is strictly for one-instance-per-connection
2285 assert(s->n_connections > 0);
2288 log_debug_unit(UNIT(s)->id, "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2291 static void socket_trigger_notify(Unit *u, Unit *other) {
2292 Socket *s = SOCKET(u);
2298 /* Don't propagate state changes from the service if we are
2299 already down or accepting connections */
2300 if ((s->state != SOCKET_RUNNING &&
2301 s->state != SOCKET_LISTENING) ||
2305 if (other->load_state != UNIT_LOADED ||
2306 other->type != UNIT_SERVICE)
2309 se = SERVICE(other);
2311 if (se->state == SERVICE_FAILED)
2312 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2314 if (se->state == SERVICE_DEAD ||
2315 se->state == SERVICE_STOP ||
2316 se->state == SERVICE_STOP_SIGTERM ||
2317 se->state == SERVICE_STOP_SIGKILL ||
2318 se->state == SERVICE_STOP_POST ||
2319 se->state == SERVICE_FINAL_SIGTERM ||
2320 se->state == SERVICE_FINAL_SIGKILL ||
2321 se->state == SERVICE_AUTO_RESTART)
2322 socket_notify_service_dead(s, false);
2324 if (se->state == SERVICE_RUNNING)
2325 socket_set_state(s, SOCKET_RUNNING);
2328 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2329 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2332 static int socket_get_timeout(Unit *u, uint64_t *timeout) {
2333 Socket *s = SOCKET(u);
2336 if (!s->timer_event_source)
2339 r = sd_event_source_get_time(s->timer_event_source, timeout);
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 .get_timeout = socket_get_timeout,
2412 .serialize = socket_serialize,
2413 .deserialize_item = socket_deserialize_item,
2414 .distribute_fds = socket_distribute_fds,
2416 .active_state = socket_active_state,
2417 .sub_state_to_string = socket_sub_state_to_string,
2419 .check_gc = socket_check_gc,
2421 .sigchld_event = socket_sigchld_event,
2423 .trigger_notify = socket_trigger_notify,
2425 .reset_failed = socket_reset_failed,
2427 .bus_interface = "org.freedesktop.systemd1.Socket",
2428 .bus_vtable = bus_socket_vtable,
2429 .bus_set_property = bus_socket_set_property,
2430 .bus_commit_properties = bus_socket_commit_properties,
2432 .status_message_formats = {
2433 /*.starting_stopping = {
2434 [0] = "Starting socket %s...",
2435 [1] = "Stopping socket %s...",
2437 .finished_start_job = {
2438 [JOB_DONE] = "Listening on %s.",
2439 [JOB_FAILED] = "Failed to listen on %s.",
2440 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2441 [JOB_TIMEOUT] = "Timed out starting %s.",
2443 .finished_stop_job = {
2444 [JOB_DONE] = "Closed %s.",
2445 [JOB_FAILED] = "Failed stopping %s.",
2446 [JOB_TIMEOUT] = "Timed out stopping %s.",