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);
125 close_nointr_nofail(p->fd);
132 static void socket_done(Unit *u) {
133 Socket *s = SOCKET(u);
137 socket_free_ports(s);
139 cgroup_context_done(&s->cgroup_context);
140 exec_context_done(&s->exec_context);
141 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
142 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
143 s->control_command = NULL;
145 socket_unwatch_control_pid(s);
147 unit_ref_unset(&s->service);
149 free(s->tcp_congestion);
150 s->tcp_congestion = NULL;
152 free(s->bind_to_device);
153 s->bind_to_device = NULL;
156 free(s->smack_ip_in);
157 free(s->smack_ip_out);
159 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
162 static int socket_arm_timer(Socket *s) {
167 if (s->timeout_usec <= 0) {
168 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
172 if (s->timer_event_source) {
173 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec);
177 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
180 return sd_event_add_monotonic(UNIT(s)->manager->event, &s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec, 0, socket_dispatch_timer, s);
183 static int socket_instantiate_service(Socket *s) {
184 _cleanup_free_ char *prefix = NULL;
185 _cleanup_free_ char *name = NULL;
191 /* This fills in s->service if it isn't filled in yet. For
192 * Accept=yes sockets we create the next connection service
193 * here. For Accept=no this is mostly a NOP since the service
194 * is figured out at load time anyway. */
196 if (UNIT_DEREF(s->service))
201 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
204 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
209 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
214 #ifdef HAVE_SYSV_COMPAT
215 if (SERVICE(u)->is_sysv) {
216 log_error("Using SysV services for socket activation is not supported. Refusing.");
222 unit_ref_set(&s->service, u);
224 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
227 static bool have_non_accept_socket(Socket *s) {
235 LIST_FOREACH(port, p, s->ports) {
237 if (p->type != SOCKET_SOCKET)
240 if (!socket_address_can_accept(&p->address))
247 static int socket_add_mount_links(Socket *s) {
253 LIST_FOREACH(port, p, s->ports) {
254 const char *path = NULL;
256 if (p->type == SOCKET_SOCKET)
257 path = socket_address_get_path(&p->address);
258 else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL)
264 r = unit_require_mounts_for(UNIT(s), path);
272 static int socket_add_device_link(Socket *s) {
277 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
280 t = strappenda("/sys/subsystem/net/devices/", s->bind_to_device);
281 return unit_add_node_link(UNIT(s), t, false);
284 static int socket_add_default_dependencies(Socket *s) {
288 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
292 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
293 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
298 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
301 _pure_ static bool socket_has_exec(Socket *s) {
305 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
306 if (s->exec_command[i])
312 static int socket_add_extras(Socket *s) {
318 if (have_non_accept_socket(s)) {
320 if (!UNIT_DEREF(s->service)) {
323 r = unit_load_related_unit(u, ".service", &x);
327 unit_ref_set(&s->service, x);
330 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
335 r = socket_add_mount_links(s);
339 r = socket_add_device_link(s);
343 r = unit_exec_context_patch_defaults(u, &s->exec_context);
347 if (socket_has_exec(s)) {
348 r = unit_add_exec_dependencies(u, &s->exec_context);
352 r = unit_add_default_slice(u);
357 if (u->default_dependencies) {
358 r = socket_add_default_dependencies(s);
366 static int socket_verify(Socket *s) {
369 if (UNIT(s)->load_state != UNIT_LOADED)
373 log_error_unit(UNIT(s)->id, "%s lacks Listen setting. Refusing.", UNIT(s)->id);
377 if (s->accept && have_non_accept_socket(s)) {
378 log_error_unit(UNIT(s)->id, "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
383 if (s->accept && s->max_connections <= 0) {
384 log_error_unit(UNIT(s)->id, "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
388 if (s->accept && UNIT_DEREF(s->service)) {
389 log_error_unit(UNIT(s)->id, "Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
393 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
394 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
401 static int socket_load(Unit *u) {
402 Socket *s = SOCKET(u);
406 assert(u->load_state == UNIT_STUB);
408 r = unit_load_fragment_and_dropin(u);
412 if (u->load_state == UNIT_LOADED) {
413 /* This is a new unit? Then let's add in some extras */
414 r = socket_add_extras(s);
419 return socket_verify(s);
422 _const_ static const char* listen_lookup(int family, int type) {
424 if (family == AF_NETLINK)
425 return "ListenNetlink";
427 if (type == SOCK_STREAM)
428 return "ListenStream";
429 else if (type == SOCK_DGRAM)
430 return "ListenDatagram";
431 else if (type == SOCK_SEQPACKET)
432 return "ListenSequentialPacket";
434 assert_not_reached("Unknown socket type");
438 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
440 Socket *s = SOCKET(u);
447 prefix2 = strappenda(prefix, "\t");
450 "%sSocket State: %s\n"
452 "%sBindIPv6Only: %s\n"
454 "%sSocketMode: %04o\n"
455 "%sDirectoryMode: %04o\n"
458 "%sTransparent: %s\n"
460 "%sPassCredentials: %s\n"
461 "%sPassSecurity: %s\n"
462 "%sTCPCongestion: %s\n",
463 prefix, socket_state_to_string(s->state),
464 prefix, socket_result_to_string(s->result),
465 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
467 prefix, s->socket_mode,
468 prefix, s->directory_mode,
469 prefix, yes_no(s->keep_alive),
470 prefix, yes_no(s->free_bind),
471 prefix, yes_no(s->transparent),
472 prefix, yes_no(s->broadcast),
473 prefix, yes_no(s->pass_cred),
474 prefix, yes_no(s->pass_sec),
475 prefix, strna(s->tcp_congestion));
477 if (s->control_pid > 0)
479 "%sControl PID: %lu\n",
480 prefix, (unsigned long) s->control_pid);
482 if (s->bind_to_device)
484 "%sBindToDevice: %s\n",
485 prefix, s->bind_to_device);
490 "%sNConnections: %u\n"
491 "%sMaxConnections: %u\n",
492 prefix, s->n_accepted,
493 prefix, s->n_connections,
494 prefix, s->max_connections);
496 if (s->priority >= 0)
499 prefix, s->priority);
501 if (s->receive_buffer > 0)
503 "%sReceiveBuffer: %zu\n",
504 prefix, s->receive_buffer);
506 if (s->send_buffer > 0)
508 "%sSendBuffer: %zu\n",
509 prefix, s->send_buffer);
521 if (s->pipe_size > 0)
524 prefix, s->pipe_size);
531 if (s->mq_maxmsg > 0)
533 "%sMessageQueueMaxMessages: %li\n",
534 prefix, s->mq_maxmsg);
536 if (s->mq_msgsize > 0)
538 "%sMessageQueueMessageSize: %li\n",
539 prefix, s->mq_msgsize);
544 prefix, yes_no(s->reuse_port));
548 "%sSmackLabel: %s\n",
553 "%sSmackLabelIPIn: %s\n",
554 prefix, s->smack_ip_in);
558 "%sSmackLabelIPOut: %s\n",
559 prefix, s->smack_ip_out);
561 LIST_FOREACH(port, p, s->ports) {
563 if (p->type == SOCKET_SOCKET) {
568 if ((r = socket_address_print(&p->address, &k)) < 0)
573 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
575 } else if (p->type == SOCKET_SPECIAL)
576 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
577 else if (p->type == SOCKET_MQUEUE)
578 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
580 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
583 exec_context_dump(&s->exec_context, f, prefix);
584 kill_context_dump(&s->kill_context, f, prefix);
586 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
587 if (!s->exec_command[c])
590 fprintf(f, "%s-> %s:\n",
591 prefix, socket_exec_command_to_string(c));
593 exec_command_dump_list(s->exec_command[c], f, prefix2);
597 static int instance_from_socket(int fd, unsigned nr, char **instance) {
600 union sockaddr_union local, remote;
606 if (getsockname(fd, &local.sa, &l) < 0)
610 if (getpeername(fd, &remote.sa, &l) < 0)
613 switch (local.sa.sa_family) {
617 a = ntohl(local.in.sin_addr.s_addr),
618 b = ntohl(remote.in.sin_addr.s_addr);
621 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
623 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
624 ntohs(local.in.sin_port),
625 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
626 ntohs(remote.in.sin_port)) < 0)
633 static const unsigned char ipv4_prefix[] = {
634 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
637 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
638 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
640 *a = local.in6.sin6_addr.s6_addr+12,
641 *b = remote.in6.sin6_addr.s6_addr+12;
644 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
646 a[0], a[1], a[2], a[3],
647 ntohs(local.in6.sin6_port),
648 b[0], b[1], b[2], b[3],
649 ntohs(remote.in6.sin6_port)) < 0)
652 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
657 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
658 ntohs(local.in6.sin6_port),
659 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
660 ntohs(remote.in6.sin6_port)) < 0)
671 k = getpeercred(fd, &ucred);
678 (unsigned long) ucred.pid,
679 (unsigned long) ucred.uid) < 0)
686 assert_not_reached("Unhandled socket type.");
693 static void socket_close_fds(Socket *s) {
698 LIST_FOREACH(port, p, s->ports) {
700 p->event_source = sd_event_source_unref(p->event_source);
705 close_nointr_nofail(p->fd);
707 /* One little note: we should never delete any sockets
708 * in the file system here! After all some other
709 * process we spawned might still have a reference of
710 * this fd and wants to continue to use it. Therefore
711 * we delete sockets in the file system before we
712 * create a new one, not after we stopped using
719 static void socket_apply_socket_options(Socket *s, int fd) {
724 int b = s->keep_alive;
725 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
726 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
731 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
732 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
737 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
738 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
743 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
744 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
747 if (s->priority >= 0)
748 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
749 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
751 if (s->receive_buffer > 0) {
752 int value = (int) s->receive_buffer;
754 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
756 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
757 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
758 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
761 if (s->send_buffer > 0) {
762 int value = (int) s->send_buffer;
763 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
764 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
765 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
769 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
770 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
773 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
774 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
776 if (s->ip_ttl >= 0) {
779 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
781 if (socket_ipv6_is_supported())
782 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
785 errno = EAFNOSUPPORT;
789 log_warning_unit(UNIT(s)->id,
790 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
793 if (s->tcp_congestion)
794 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
795 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
798 int b = s->reuse_port;
799 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)) < 0)
800 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
804 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
805 log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
808 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
809 log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
812 static void socket_apply_fifo_options(Socket *s, int fd) {
816 if (s->pipe_size > 0)
817 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
818 log_warning_unit(UNIT(s)->id,
822 if (smack_label_fd(fd, s->smack) < 0)
823 log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
826 static int fifo_address_create(
828 mode_t directory_mode,
839 mkdir_parents_label(path, directory_mode);
841 r = label_context_set(path, S_IFIFO);
845 /* Enforce the right access mode for the fifo */
846 old_mask = umask(~ socket_mode);
848 /* Include the original umask in our mask */
849 umask(~socket_mode | old_mask);
851 r = mkfifo(path, socket_mode);
854 if (r < 0 && errno != EEXIST) {
859 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
864 label_context_clear();
866 if (fstat(fd, &st) < 0) {
871 if (!S_ISFIFO(st.st_mode) ||
872 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
873 st.st_uid != getuid() ||
874 st.st_gid != getgid()) {
884 label_context_clear();
887 close_nointr_nofail(fd);
892 static int special_address_create(
902 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
907 if (fstat(fd, &st) < 0) {
912 /* Check whether this is a /proc, /sys or /dev file or char device */
913 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
923 close_nointr_nofail(fd);
928 static int mq_address_create(
938 struct mq_attr _attr, *attr = NULL;
943 if (maxmsg > 0 && msgsize > 0) {
945 _attr.mq_flags = O_NONBLOCK;
946 _attr.mq_maxmsg = maxmsg;
947 _attr.mq_msgsize = msgsize;
951 /* Enforce the right access mode for the mq */
952 old_mask = umask(~ mq_mode);
954 /* Include the original umask in our mask */
955 umask(~mq_mode | old_mask);
957 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
965 if (fstat(fd, &st) < 0) {
970 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
971 st.st_uid != getuid() ||
972 st.st_gid != getgid()) {
983 close_nointr_nofail(fd);
988 static int socket_open_fds(Socket *s) {
992 bool know_label = false;
996 LIST_FOREACH(port, p, s->ports) {
1001 if (p->type == SOCKET_SOCKET) {
1005 if ((r = socket_instantiate_service(s)) < 0)
1008 if (UNIT_ISSET(s->service) &&
1009 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1010 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1021 r = socket_address_listen(
1023 SOCK_CLOEXEC|SOCK_NONBLOCK,
1036 socket_apply_socket_options(s, p->fd);
1038 } else if (p->type == SOCKET_SPECIAL) {
1040 r = special_address_create(
1046 } else if (p->type == SOCKET_FIFO) {
1048 r = fifo_address_create(
1056 socket_apply_fifo_options(s, p->fd);
1057 } else if (p->type == SOCKET_MQUEUE) {
1059 r = mq_address_create(
1068 assert_not_reached("Unknown port type");
1075 socket_close_fds(s);
1080 static void socket_unwatch_fds(Socket *s) {
1086 LIST_FOREACH(port, p, s->ports) {
1090 if (p->event_source) {
1091 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_OFF);
1093 log_debug_unit(UNIT(s)->id, "Failed to disable event source.");
1098 static int socket_watch_fds(Socket *s) {
1104 LIST_FOREACH(port, p, s->ports) {
1108 if (p->event_source)
1109 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1111 r = sd_event_add_io(UNIT(s)->manager->event, &p->event_source, p->fd, EPOLLIN, socket_dispatch_io, p);
1114 log_warning_unit(UNIT(s)->id, "Failed to watch listening fds: %s", strerror(-r));
1122 socket_unwatch_fds(s);
1126 static void socket_set_state(Socket *s, SocketState state) {
1127 SocketState old_state;
1130 old_state = s->state;
1133 if (state != SOCKET_START_PRE &&
1134 state != SOCKET_START_POST &&
1135 state != SOCKET_STOP_PRE &&
1136 state != SOCKET_STOP_PRE_SIGTERM &&
1137 state != SOCKET_STOP_PRE_SIGKILL &&
1138 state != SOCKET_STOP_POST &&
1139 state != SOCKET_FINAL_SIGTERM &&
1140 state != SOCKET_FINAL_SIGKILL) {
1142 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1143 socket_unwatch_control_pid(s);
1144 s->control_command = NULL;
1145 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1148 if (state != SOCKET_LISTENING)
1149 socket_unwatch_fds(s);
1151 if (state != SOCKET_START_POST &&
1152 state != SOCKET_LISTENING &&
1153 state != SOCKET_RUNNING &&
1154 state != SOCKET_STOP_PRE &&
1155 state != SOCKET_STOP_PRE_SIGTERM &&
1156 state != SOCKET_STOP_PRE_SIGKILL)
1157 socket_close_fds(s);
1159 if (state != old_state)
1160 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s",
1161 UNIT(s)->id, socket_state_to_string(old_state), socket_state_to_string(state));
1163 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1166 static int socket_coldplug(Unit *u) {
1167 Socket *s = SOCKET(u);
1171 assert(s->state == SOCKET_DEAD);
1173 if (s->deserialized_state == s->state)
1176 if (s->deserialized_state == SOCKET_START_PRE ||
1177 s->deserialized_state == SOCKET_START_POST ||
1178 s->deserialized_state == SOCKET_STOP_PRE ||
1179 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1180 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1181 s->deserialized_state == SOCKET_STOP_POST ||
1182 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1183 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1185 if (s->control_pid <= 0)
1188 r = unit_watch_pid(UNIT(s), s->control_pid);
1192 r = socket_arm_timer(s);
1197 if (s->deserialized_state == SOCKET_START_POST ||
1198 s->deserialized_state == SOCKET_LISTENING ||
1199 s->deserialized_state == SOCKET_RUNNING ||
1200 s->deserialized_state == SOCKET_STOP_PRE ||
1201 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1202 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL) {
1203 r = socket_open_fds(s);
1208 if (s->deserialized_state == SOCKET_LISTENING) {
1209 r = socket_watch_fds(s);
1214 socket_set_state(s, s->deserialized_state);
1218 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1227 unit_realize_cgroup(UNIT(s));
1229 r = unit_setup_exec_runtime(UNIT(s));
1233 r = socket_arm_timer(s);
1237 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1245 UNIT(s)->manager->environment,
1249 UNIT(s)->manager->confirm_spawn,
1250 UNIT(s)->manager->cgroup_supported,
1251 UNIT(s)->cgroup_path,
1252 manager_get_runtime_prefix(UNIT(s)->manager),
1263 r = unit_watch_pid(UNIT(s), pid);
1265 /* FIXME: we need to do something here */
1273 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1278 static void socket_enter_dead(Socket *s, SocketResult f) {
1281 if (f != SOCKET_SUCCESS)
1284 exec_runtime_destroy(s->exec_runtime);
1285 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1287 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
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)
1347 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_SUCCESS);
1348 else if (state == SOCKET_STOP_PRE_SIGKILL)
1349 socket_enter_stop_post(s, SOCKET_SUCCESS);
1350 else if (state == SOCKET_FINAL_SIGTERM)
1351 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
1353 socket_enter_dead(s, SOCKET_SUCCESS);
1358 log_warning_unit(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1360 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1361 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1363 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1366 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1370 if (f != SOCKET_SUCCESS)
1373 socket_unwatch_control_pid(s);
1375 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1377 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1378 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1381 socket_set_state(s, SOCKET_STOP_PRE);
1383 socket_enter_stop_post(s, SOCKET_SUCCESS);
1388 log_warning_unit(UNIT(s)->id, "%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1389 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1392 static void socket_enter_listening(Socket *s) {
1396 r = socket_watch_fds(s);
1398 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1402 socket_set_state(s, SOCKET_LISTENING);
1406 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1409 static void socket_enter_start_post(Socket *s) {
1413 r = socket_open_fds(s);
1415 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1419 socket_unwatch_control_pid(s);
1421 s->control_command_id = SOCKET_EXEC_START_POST;
1423 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1424 r = socket_spawn(s, s->control_command, &s->control_pid);
1426 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1430 socket_set_state(s, SOCKET_START_POST);
1432 socket_enter_listening(s);
1437 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1440 static void socket_enter_start_pre(Socket *s) {
1444 socket_unwatch_control_pid(s);
1446 s->control_command_id = SOCKET_EXEC_START_PRE;
1448 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1449 r = socket_spawn(s, s->control_command, &s->control_pid);
1453 socket_set_state(s, SOCKET_START_PRE);
1455 socket_enter_start_post(s);
1460 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1461 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1464 static void socket_enter_running(Socket *s, int cfd) {
1465 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1470 /* We don't take connections anymore if we are supposed to
1471 * shut down anyway */
1472 if (unit_stop_pending(UNIT(s))) {
1474 log_debug_unit(UNIT(s)->id, "Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1477 close_nointr_nofail(cfd);
1479 /* Flush all sockets by closing and reopening them */
1480 socket_close_fds(s);
1482 r = socket_open_fds(s);
1484 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1485 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1489 r = socket_watch_fds(s);
1491 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1492 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1502 bool pending = false;
1504 /* If there's already a start pending don't bother to
1506 SET_FOREACH(other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1507 if (unit_active_or_pending(other)) {
1513 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1518 socket_set_state(s, SOCKET_RUNNING);
1520 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1523 if (s->n_connections >= s->max_connections) {
1524 log_warning_unit(UNIT(s)->id, "%s: Too many incoming connections (%u)", UNIT(s)->id, s->n_connections);
1525 close_nointr_nofail(cfd);
1529 r = socket_instantiate_service(s);
1533 r = instance_from_socket(cfd, s->n_accepted, &instance);
1538 /* ENOTCONN is legitimate if TCP RST was received.
1539 * This connection is over, but the socket unit lives on. */
1540 close_nointr_nofail(cfd);
1544 prefix = unit_name_to_prefix(UNIT(s)->id);
1550 name = unit_name_build(prefix, instance, ".service");
1556 r = unit_add_name(UNIT_DEREF(s->service), name);
1560 service = SERVICE(UNIT_DEREF(s->service));
1561 unit_ref_unset(&s->service);
1564 UNIT(service)->no_gc = false;
1566 unit_choose_id(UNIT(service), name);
1568 r = service_set_socket_fd(service, cfd, s);
1573 s->n_connections ++;
1575 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1579 /* Notify clients about changed counters */
1580 unit_add_to_dbus_queue(UNIT(s));
1586 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",
1587 UNIT(s)->id, cfd >= 0 ? "template" : "non-template",
1588 bus_error_message(&error, r));
1590 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1593 close_nointr_nofail(cfd);
1596 static void socket_run_next(Socket *s) {
1600 assert(s->control_command);
1601 assert(s->control_command->command_next);
1603 socket_unwatch_control_pid(s);
1605 s->control_command = s->control_command->command_next;
1607 r = socket_spawn(s, s->control_command, &s->control_pid);
1614 log_warning_unit(UNIT(s)->id, "%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1616 if (s->state == SOCKET_START_POST)
1617 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1618 else if (s->state == SOCKET_STOP_POST)
1619 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1621 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1624 static int socket_start(Unit *u) {
1625 Socket *s = SOCKET(u);
1629 /* We cannot fulfill this request right now, try again later
1631 if (s->state == SOCKET_STOP_PRE ||
1632 s->state == SOCKET_STOP_PRE_SIGKILL ||
1633 s->state == SOCKET_STOP_PRE_SIGTERM ||
1634 s->state == SOCKET_STOP_POST ||
1635 s->state == SOCKET_FINAL_SIGTERM ||
1636 s->state == SOCKET_FINAL_SIGKILL)
1639 if (s->state == SOCKET_START_PRE ||
1640 s->state == SOCKET_START_POST)
1643 /* Cannot run this without the service being around */
1644 if (UNIT_ISSET(s->service)) {
1647 service = SERVICE(UNIT_DEREF(s->service));
1649 if (UNIT(service)->load_state != UNIT_LOADED) {
1650 log_error_unit(u->id, "Socket service %s not loaded, refusing.", UNIT(service)->id);
1654 /* If the service is already active we cannot start the
1656 if (service->state != SERVICE_DEAD &&
1657 service->state != SERVICE_FAILED &&
1658 service->state != SERVICE_AUTO_RESTART) {
1659 log_error_unit(u->id, "Socket service %s already active, refusing.", UNIT(service)->id);
1663 #ifdef HAVE_SYSV_COMPAT
1664 if (service->is_sysv) {
1665 log_error_unit(u->id,
1666 "Using SysV services for socket activation is not supported. Refusing.");
1672 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1674 s->result = SOCKET_SUCCESS;
1675 socket_enter_start_pre(s);
1680 static int socket_stop(Unit *u) {
1681 Socket *s = SOCKET(u);
1686 if (s->state == SOCKET_STOP_PRE ||
1687 s->state == SOCKET_STOP_PRE_SIGTERM ||
1688 s->state == SOCKET_STOP_PRE_SIGKILL ||
1689 s->state == SOCKET_STOP_POST ||
1690 s->state == SOCKET_FINAL_SIGTERM ||
1691 s->state == SOCKET_FINAL_SIGKILL)
1694 /* If there's already something running we go directly into
1696 if (s->state == SOCKET_START_PRE ||
1697 s->state == SOCKET_START_POST) {
1698 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1702 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1704 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1708 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1709 Socket *s = SOCKET(u);
1717 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1718 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1719 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1721 if (s->control_pid > 0)
1722 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1724 if (s->control_command_id >= 0)
1725 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1727 LIST_FOREACH(port, p, s->ports) {
1733 copy = fdset_put_dup(fds, p->fd);
1737 if (p->type == SOCKET_SOCKET) {
1738 _cleanup_free_ char *t = NULL;
1740 r = socket_address_print(&p->address, &t);
1744 if (socket_address_family(&p->address) == AF_NETLINK)
1745 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1747 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1749 } else if (p->type == SOCKET_SPECIAL)
1750 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1751 else if (p->type == SOCKET_MQUEUE)
1752 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1754 assert(p->type == SOCKET_FIFO);
1755 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1762 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1763 Socket *s = SOCKET(u);
1769 if (streq(key, "state")) {
1772 state = socket_state_from_string(value);
1774 log_debug_unit(u->id, "Failed to parse state value %s", value);
1776 s->deserialized_state = state;
1777 } else if (streq(key, "result")) {
1780 f = socket_result_from_string(value);
1782 log_debug_unit(u->id, "Failed to parse result value %s", value);
1783 else if (f != SOCKET_SUCCESS)
1786 } else if (streq(key, "n-accepted")) {
1789 if (safe_atou(value, &k) < 0)
1790 log_debug_unit(u->id, "Failed to parse n-accepted value %s", value);
1793 } else if (streq(key, "control-pid")) {
1796 if (parse_pid(value, &pid) < 0)
1797 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1799 s->control_pid = pid;
1800 } else if (streq(key, "control-command")) {
1801 SocketExecCommand id;
1803 id = socket_exec_command_from_string(value);
1805 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1807 s->control_command_id = id;
1808 s->control_command = s->exec_command[id];
1810 } else if (streq(key, "fifo")) {
1814 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1815 log_debug_unit(u->id, "Failed to parse fifo value %s", value);
1818 LIST_FOREACH(port, p, s->ports)
1819 if (p->type == SOCKET_FIFO &&
1820 streq_ptr(p->path, value+skip))
1825 close_nointr_nofail(p->fd);
1826 p->fd = fdset_remove(fds, fd);
1830 } else if (streq(key, "special")) {
1834 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1835 log_debug_unit(u->id, "Failed to parse special value %s", value);
1838 LIST_FOREACH(port, p, s->ports)
1839 if (p->type == SOCKET_SPECIAL &&
1840 streq_ptr(p->path, value+skip))
1845 close_nointr_nofail(p->fd);
1846 p->fd = fdset_remove(fds, fd);
1850 } else if (streq(key, "mqueue")) {
1854 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1855 log_debug_unit(u->id, "Failed to parse mqueue value %s", value);
1858 LIST_FOREACH(port, p, s->ports)
1859 if (p->type == SOCKET_MQUEUE &&
1860 streq_ptr(p->path, value+skip))
1865 close_nointr_nofail(p->fd);
1866 p->fd = fdset_remove(fds, fd);
1870 } else if (streq(key, "socket")) {
1871 int fd, type, skip = 0;
1874 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1875 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1878 LIST_FOREACH(port, p, s->ports)
1879 if (socket_address_is(&p->address, value+skip, type))
1884 close_nointr_nofail(p->fd);
1885 p->fd = fdset_remove(fds, fd);
1889 } else if (streq(key, "netlink")) {
1893 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1894 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1897 LIST_FOREACH(port, p, s->ports)
1898 if (socket_address_is_netlink(&p->address, value+skip))
1903 close_nointr_nofail(p->fd);
1904 p->fd = fdset_remove(fds, fd);
1908 log_debug_unit(UNIT(s)->id, "Unknown serialization key '%s'", key);
1913 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1914 Socket *s = SOCKET(u);
1919 LIST_FOREACH(port, p, s->ports) {
1923 if (p->type != SOCKET_SOCKET)
1929 FDSET_FOREACH(fd, fds, i) {
1930 if (socket_address_matches_fd(&p->address, fd)) {
1931 p->fd = fdset_remove(fds, fd);
1932 s->deserialized_state = SOCKET_LISTENING;
1941 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1944 return state_translation_table[SOCKET(u)->state];
1947 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1950 return socket_state_to_string(SOCKET(u)->state);
1953 const char* socket_port_type_to_string(SocketPort *p) {
1961 switch (p->address.type) {
1969 case SOCK_SEQPACKET:
1970 return "SequentialPacket";
1973 if (socket_address_family(&p->address) == AF_NETLINK)
1980 case SOCKET_SPECIAL:
1984 return "MessageQueue";
1994 _pure_ static bool socket_check_gc(Unit *u) {
1995 Socket *s = SOCKET(u);
1999 return s->n_connections > 0;
2002 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2003 SocketPort *p = userdata;
2009 if (p->socket->state != SOCKET_LISTENING)
2012 log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
2014 if (revents != EPOLLIN) {
2016 if (revents & EPOLLHUP)
2017 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.",
2018 UNIT(p->socket)->id);
2020 log_error_unit(UNIT(p->socket)->id, "%s: Got unexpected poll event (0x%x) on socket.",
2021 UNIT(p->socket)->id, revents);
2026 if (p->socket->accept &&
2027 p->type == SOCKET_SOCKET &&
2028 socket_address_can_accept(&p->address)) {
2032 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2038 log_error_unit(UNIT(p->socket)->id,
2039 "Failed to accept socket: %m");
2046 socket_apply_socket_options(p->socket, cfd);
2049 socket_enter_running(p->socket, cfd);
2053 socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2057 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2058 Socket *s = SOCKET(u);
2064 if (pid != s->control_pid)
2069 if (is_clean_exit(code, status, NULL))
2071 else if (code == CLD_EXITED)
2072 f = SOCKET_FAILURE_EXIT_CODE;
2073 else if (code == CLD_KILLED)
2074 f = SOCKET_FAILURE_SIGNAL;
2075 else if (code == CLD_DUMPED)
2076 f = SOCKET_FAILURE_CORE_DUMP;
2078 assert_not_reached("Unknown code");
2080 if (s->control_command) {
2081 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2083 if (s->control_command->ignore)
2087 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2089 "%s control process exited, code=%s status=%i",
2090 u->id, sigchld_code_to_string(code), status);
2092 if (f != SOCKET_SUCCESS)
2095 if (s->control_command &&
2096 s->control_command->command_next &&
2097 f == SOCKET_SUCCESS) {
2099 log_debug_unit(u->id,
2100 "%s running next command for state %s",
2101 u->id, socket_state_to_string(s->state));
2104 s->control_command = NULL;
2105 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2107 /* No further commands for this step, so let's figure
2108 * out what to do next */
2110 log_debug_unit(u->id,
2111 "%s got final SIGCHLD for state %s",
2112 u->id, socket_state_to_string(s->state));
2116 case SOCKET_START_PRE:
2117 if (f == SOCKET_SUCCESS)
2118 socket_enter_start_post(s);
2120 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2123 case SOCKET_START_POST:
2124 if (f == SOCKET_SUCCESS)
2125 socket_enter_listening(s);
2127 socket_enter_stop_pre(s, f);
2130 case SOCKET_STOP_PRE:
2131 case SOCKET_STOP_PRE_SIGTERM:
2132 case SOCKET_STOP_PRE_SIGKILL:
2133 socket_enter_stop_post(s, f);
2136 case SOCKET_STOP_POST:
2137 case SOCKET_FINAL_SIGTERM:
2138 case SOCKET_FINAL_SIGKILL:
2139 socket_enter_dead(s, f);
2143 assert_not_reached("Uh, control process died at wrong time.");
2147 /* Notify clients about changed exit status */
2148 unit_add_to_dbus_queue(u);
2151 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2152 Socket *s = SOCKET(userdata);
2155 assert(s->timer_event_source == source);
2159 case SOCKET_START_PRE:
2160 log_warning_unit(UNIT(s)->id,
2161 "%s starting timed out. Terminating.", UNIT(s)->id);
2162 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2165 case SOCKET_START_POST:
2166 log_warning_unit(UNIT(s)->id,
2167 "%s starting timed out. Stopping.", UNIT(s)->id);
2168 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2171 case SOCKET_STOP_PRE:
2172 log_warning_unit(UNIT(s)->id,
2173 "%s stopping timed out. Terminating.", UNIT(s)->id);
2174 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2177 case SOCKET_STOP_PRE_SIGTERM:
2178 if (s->kill_context.send_sigkill) {
2179 log_warning_unit(UNIT(s)->id,
2180 "%s stopping timed out. Killing.", UNIT(s)->id);
2181 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2183 log_warning_unit(UNIT(s)->id,
2184 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2186 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2190 case SOCKET_STOP_PRE_SIGKILL:
2191 log_warning_unit(UNIT(s)->id,
2192 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2193 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2196 case SOCKET_STOP_POST:
2197 log_warning_unit(UNIT(s)->id,
2198 "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2199 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2202 case SOCKET_FINAL_SIGTERM:
2203 if (s->kill_context.send_sigkill) {
2204 log_warning_unit(UNIT(s)->id,
2205 "%s stopping timed out (2). Killing.", UNIT(s)->id);
2206 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2208 log_warning_unit(UNIT(s)->id,
2209 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2211 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2215 case SOCKET_FINAL_SIGKILL:
2216 log_warning_unit(UNIT(s)->id,
2217 "%s still around after SIGKILL (2). Entering failed mode.",
2219 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2223 assert_not_reached("Timeout at wrong time.");
2229 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2238 /* Called from the service code for requesting our fds */
2241 LIST_FOREACH(port, p, s->ports)
2251 if (!(rfds = new(int, rn_fds)))
2255 LIST_FOREACH(port, p, s->ports)
2259 assert(k == rn_fds);
2267 static void socket_reset_failed(Unit *u) {
2268 Socket *s = SOCKET(u);
2272 if (s->state == SOCKET_FAILED)
2273 socket_set_state(s, SOCKET_DEAD);
2275 s->result = SOCKET_SUCCESS;
2278 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2281 /* The service is dead. Dang!
2283 * This is strictly for one-instance-for-all-connections
2286 if (s->state == SOCKET_RUNNING) {
2287 log_debug_unit(UNIT(s)->id, "%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2288 if (failed_permanent)
2289 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2291 socket_enter_listening(s);
2295 void socket_connection_unref(Socket *s) {
2298 /* The service is dead. Yay!
2300 * This is strictly for one-instance-per-connection
2303 assert(s->n_connections > 0);
2306 log_debug_unit(UNIT(s)->id, "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2309 static void socket_trigger_notify(Unit *u, Unit *other) {
2310 Socket *s = SOCKET(u);
2316 /* Don't propagate state changes from the service if we are
2317 already down or accepting connections */
2318 if ((s->state != SOCKET_RUNNING &&
2319 s->state != SOCKET_LISTENING) ||
2323 if (other->load_state != UNIT_LOADED ||
2324 other->type != UNIT_SERVICE)
2327 se = SERVICE(other);
2329 if (se->state == SERVICE_FAILED)
2330 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2332 if (se->state == SERVICE_DEAD ||
2333 se->state == SERVICE_STOP ||
2334 se->state == SERVICE_STOP_SIGTERM ||
2335 se->state == SERVICE_STOP_SIGKILL ||
2336 se->state == SERVICE_STOP_POST ||
2337 se->state == SERVICE_FINAL_SIGTERM ||
2338 se->state == SERVICE_FINAL_SIGKILL ||
2339 se->state == SERVICE_AUTO_RESTART)
2340 socket_notify_service_dead(s, false);
2342 if (se->state == SERVICE_RUNNING)
2343 socket_set_state(s, SOCKET_RUNNING);
2346 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2347 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2350 static int socket_get_timeout(Unit *u, uint64_t *timeout) {
2351 Socket *s = SOCKET(u);
2354 if (!s->timer_event_source)
2357 r = sd_event_source_get_time(s->timer_event_source, timeout);
2364 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2365 [SOCKET_DEAD] = "dead",
2366 [SOCKET_START_PRE] = "start-pre",
2367 [SOCKET_START_POST] = "start-post",
2368 [SOCKET_LISTENING] = "listening",
2369 [SOCKET_RUNNING] = "running",
2370 [SOCKET_STOP_PRE] = "stop-pre",
2371 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2372 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2373 [SOCKET_STOP_POST] = "stop-post",
2374 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2375 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2376 [SOCKET_FAILED] = "failed"
2379 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2381 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2382 [SOCKET_EXEC_START_PRE] = "StartPre",
2383 [SOCKET_EXEC_START_POST] = "StartPost",
2384 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2385 [SOCKET_EXEC_STOP_POST] = "StopPost"
2388 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2390 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2391 [SOCKET_SUCCESS] = "success",
2392 [SOCKET_FAILURE_RESOURCES] = "resources",
2393 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2394 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2395 [SOCKET_FAILURE_SIGNAL] = "signal",
2396 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2397 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2400 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2402 const UnitVTable socket_vtable = {
2403 .object_size = sizeof(Socket),
2404 .exec_context_offset = offsetof(Socket, exec_context),
2405 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2406 .kill_context_offset = offsetof(Socket, kill_context),
2407 .exec_runtime_offset = offsetof(Socket, exec_runtime),
2413 .private_section = "Socket",
2415 .init = socket_init,
2416 .done = socket_done,
2417 .load = socket_load,
2419 .coldplug = socket_coldplug,
2421 .dump = socket_dump,
2423 .start = socket_start,
2424 .stop = socket_stop,
2426 .kill = socket_kill,
2428 .get_timeout = socket_get_timeout,
2430 .serialize = socket_serialize,
2431 .deserialize_item = socket_deserialize_item,
2432 .distribute_fds = socket_distribute_fds,
2434 .active_state = socket_active_state,
2435 .sub_state_to_string = socket_sub_state_to_string,
2437 .check_gc = socket_check_gc,
2439 .sigchld_event = socket_sigchld_event,
2441 .trigger_notify = socket_trigger_notify,
2443 .reset_failed = socket_reset_failed,
2445 .bus_interface = "org.freedesktop.systemd1.Socket",
2446 .bus_vtable = bus_socket_vtable,
2447 .bus_set_property = bus_socket_set_property,
2448 .bus_commit_properties = bus_socket_commit_properties,
2450 .status_message_formats = {
2451 /*.starting_stopping = {
2452 [0] = "Starting socket %s...",
2453 [1] = "Stopping socket %s...",
2455 .finished_start_job = {
2456 [JOB_DONE] = "Listening on %s.",
2457 [JOB_FAILED] = "Failed to listen on %s.",
2458 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2459 [JOB_TIMEOUT] = "Timed out starting %s.",
2461 .finished_stop_job = {
2462 [JOB_DONE] = "Closed %s.",
2463 [JOB_FAILED] = "Failed stopping %s.",
2464 [JOB_TIMEOUT] = "Timed out stopping %s.",