1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include <sys/types.h>
27 #include <sys/epoll.h>
29 #include <arpa/inet.h>
30 #include <netinet/tcp.h>
33 #include <attr/xattr.h>
38 #include "load-dropin.h"
39 #include "load-fragment.h"
42 #include "path-util.h"
43 #include "unit-name.h"
44 #include "unit-printf.h"
48 #include "exit-status.h"
50 #include "smack-util.h"
52 #include "bus-error.h"
53 #include "dbus-socket.h"
57 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
58 [SOCKET_DEAD] = UNIT_INACTIVE,
59 [SOCKET_START_PRE] = UNIT_ACTIVATING,
60 [SOCKET_START_POST] = UNIT_ACTIVATING,
61 [SOCKET_LISTENING] = UNIT_ACTIVE,
62 [SOCKET_RUNNING] = UNIT_ACTIVE,
63 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
64 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
65 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
66 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
67 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
68 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
69 [SOCKET_FAILED] = UNIT_FAILED
72 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
73 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
75 static void socket_init(Unit *u) {
76 Socket *s = SOCKET(u);
79 assert(u->load_state == UNIT_STUB);
81 s->backlog = SOMAXCONN;
82 s->timeout_usec = u->manager->default_timeout_start_usec;
83 s->directory_mode = 0755;
84 s->socket_mode = 0666;
86 s->max_connections = 64;
93 exec_context_init(&s->exec_context);
94 s->exec_context.std_output = u->manager->default_std_output;
95 s->exec_context.std_error = u->manager->default_std_error;
96 kill_context_init(&s->kill_context);
97 cgroup_context_init(&s->cgroup_context);
99 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
102 static void socket_unwatch_control_pid(Socket *s) {
105 if (s->control_pid <= 0)
108 unit_unwatch_pid(UNIT(s), s->control_pid);
112 void socket_free_ports(Socket *s) {
117 while ((p = s->ports)) {
118 LIST_REMOVE(port, s->ports, p);
120 sd_event_source_unref(p->event_source);
123 close_nointr_nofail(p->fd);
130 static void socket_done(Unit *u) {
131 Socket *s = SOCKET(u);
135 socket_free_ports(s);
137 cgroup_context_done(&s->cgroup_context);
138 exec_context_done(&s->exec_context);
139 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
140 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
141 s->control_command = NULL;
143 socket_unwatch_control_pid(s);
145 unit_ref_unset(&s->service);
147 free(s->tcp_congestion);
148 s->tcp_congestion = NULL;
150 free(s->bind_to_device);
151 s->bind_to_device = NULL;
154 free(s->smack_ip_in);
155 free(s->smack_ip_out);
157 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
160 static int socket_arm_timer(Socket *s) {
165 if (s->timeout_usec <= 0) {
166 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
170 if (s->timer_event_source) {
171 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec);
175 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
178 return sd_event_add_monotonic(UNIT(s)->manager->event, now(CLOCK_MONOTONIC) + s->timeout_usec, 0, socket_dispatch_timer, s, &s->timer_event_source);
181 static int socket_instantiate_service(Socket *s) {
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 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
202 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
207 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
212 #ifdef HAVE_SYSV_COMPAT
213 if (SERVICE(u)->is_sysv) {
214 log_error("Using SysV services for socket activation is not supported. Refusing.");
220 unit_ref_set(&s->service, u);
222 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
225 static bool have_non_accept_socket(Socket *s) {
233 LIST_FOREACH(port, p, s->ports) {
235 if (p->type != SOCKET_SOCKET)
238 if (!socket_address_can_accept(&p->address))
245 static int socket_add_mount_links(Socket *s) {
251 LIST_FOREACH(port, p, s->ports) {
252 const char *path = NULL;
254 if (p->type == SOCKET_SOCKET)
255 path = socket_address_get_path(&p->address);
256 else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL)
262 r = unit_require_mounts_for(UNIT(s), path);
270 static int socket_add_device_link(Socket *s) {
275 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
278 t = strappenda("/sys/subsystem/net/devices/", s->bind_to_device);
279 return unit_add_node_link(UNIT(s), t, false);
282 static int socket_add_default_dependencies(Socket *s) {
286 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
290 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
291 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
296 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
299 _pure_ static bool socket_has_exec(Socket *s) {
303 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
304 if (s->exec_command[i])
310 static int socket_add_extras(Socket *s) {
316 if (have_non_accept_socket(s)) {
318 if (!UNIT_DEREF(s->service)) {
321 r = unit_load_related_unit(u, ".service", &x);
325 unit_ref_set(&s->service, x);
328 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
333 r = socket_add_mount_links(s);
337 r = socket_add_device_link(s);
341 r = unit_exec_context_defaults(u, &s->exec_context);
345 if (socket_has_exec(s)) {
346 r = unit_add_exec_dependencies(u, &s->exec_context);
350 r = unit_add_default_slice(u);
355 if (u->default_dependencies) {
356 r = socket_add_default_dependencies(s);
364 static int socket_verify(Socket *s) {
367 if (UNIT(s)->load_state != UNIT_LOADED)
371 log_error_unit(UNIT(s)->id, "%s lacks Listen setting. Refusing.", UNIT(s)->id);
375 if (s->accept && have_non_accept_socket(s)) {
376 log_error_unit(UNIT(s)->id, "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
381 if (s->accept && s->max_connections <= 0) {
382 log_error_unit(UNIT(s)->id, "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
386 if (s->accept && UNIT_DEREF(s->service)) {
387 log_error_unit(UNIT(s)->id, "Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
391 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
392 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
399 static int socket_load(Unit *u) {
400 Socket *s = SOCKET(u);
404 assert(u->load_state == UNIT_STUB);
406 r = unit_load_fragment_and_dropin(u);
410 if (u->load_state == UNIT_LOADED) {
411 /* This is a new unit? Then let's add in some extras */
412 r = socket_add_extras(s);
417 return socket_verify(s);
420 _const_ static const char* listen_lookup(int family, int type) {
422 if (family == AF_NETLINK)
423 return "ListenNetlink";
425 if (type == SOCK_STREAM)
426 return "ListenStream";
427 else if (type == SOCK_DGRAM)
428 return "ListenDatagram";
429 else if (type == SOCK_SEQPACKET)
430 return "ListenSequentialPacket";
432 assert_not_reached("Unknown socket type");
436 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
438 Socket *s = SOCKET(u);
445 prefix2 = strappenda(prefix, "\t");
448 "%sSocket State: %s\n"
450 "%sBindIPv6Only: %s\n"
452 "%sSocketMode: %04o\n"
453 "%sDirectoryMode: %04o\n"
456 "%sTransparent: %s\n"
458 "%sPassCredentials: %s\n"
459 "%sPassSecurity: %s\n"
460 "%sTCPCongestion: %s\n",
461 prefix, socket_state_to_string(s->state),
462 prefix, socket_result_to_string(s->result),
463 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
465 prefix, s->socket_mode,
466 prefix, s->directory_mode,
467 prefix, yes_no(s->keep_alive),
468 prefix, yes_no(s->free_bind),
469 prefix, yes_no(s->transparent),
470 prefix, yes_no(s->broadcast),
471 prefix, yes_no(s->pass_cred),
472 prefix, yes_no(s->pass_sec),
473 prefix, strna(s->tcp_congestion));
475 if (s->control_pid > 0)
477 "%sControl PID: %lu\n",
478 prefix, (unsigned long) s->control_pid);
480 if (s->bind_to_device)
482 "%sBindToDevice: %s\n",
483 prefix, s->bind_to_device);
488 "%sNConnections: %u\n"
489 "%sMaxConnections: %u\n",
490 prefix, s->n_accepted,
491 prefix, s->n_connections,
492 prefix, s->max_connections);
494 if (s->priority >= 0)
497 prefix, s->priority);
499 if (s->receive_buffer > 0)
501 "%sReceiveBuffer: %zu\n",
502 prefix, s->receive_buffer);
504 if (s->send_buffer > 0)
506 "%sSendBuffer: %zu\n",
507 prefix, s->send_buffer);
519 if (s->pipe_size > 0)
522 prefix, s->pipe_size);
529 if (s->mq_maxmsg > 0)
531 "%sMessageQueueMaxMessages: %li\n",
532 prefix, s->mq_maxmsg);
534 if (s->mq_msgsize > 0)
536 "%sMessageQueueMessageSize: %li\n",
537 prefix, s->mq_msgsize);
542 prefix, yes_no(s->reuse_port));
546 "%sSmackLabel: %s\n",
551 "%sSmackLabelIPIn: %s\n",
552 prefix, s->smack_ip_in);
556 "%sSmackLabelIPOut: %s\n",
557 prefix, s->smack_ip_out);
559 LIST_FOREACH(port, p, s->ports) {
561 if (p->type == SOCKET_SOCKET) {
566 if ((r = socket_address_print(&p->address, &k)) < 0)
571 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
573 } else if (p->type == SOCKET_SPECIAL)
574 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
575 else if (p->type == SOCKET_MQUEUE)
576 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
578 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
581 exec_context_dump(&s->exec_context, f, prefix);
582 kill_context_dump(&s->kill_context, f, prefix);
584 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
585 if (!s->exec_command[c])
588 fprintf(f, "%s-> %s:\n",
589 prefix, socket_exec_command_to_string(c));
591 exec_command_dump_list(s->exec_command[c], f, prefix2);
595 static int instance_from_socket(int fd, unsigned nr, char **instance) {
600 struct sockaddr_un un;
601 struct sockaddr_in in;
602 struct sockaddr_in6 in6;
603 struct sockaddr_storage storage;
610 if (getsockname(fd, &local.sa, &l) < 0)
614 if (getpeername(fd, &remote.sa, &l) < 0)
617 switch (local.sa.sa_family) {
621 a = ntohl(local.in.sin_addr.s_addr),
622 b = ntohl(remote.in.sin_addr.s_addr);
625 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
627 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
628 ntohs(local.in.sin_port),
629 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
630 ntohs(remote.in.sin_port)) < 0)
637 static const unsigned char ipv4_prefix[] = {
638 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
641 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
642 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
644 *a = local.in6.sin6_addr.s6_addr+12,
645 *b = remote.in6.sin6_addr.s6_addr+12;
648 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
650 a[0], a[1], a[2], a[3],
651 ntohs(local.in6.sin6_port),
652 b[0], b[1], b[2], b[3],
653 ntohs(remote.in6.sin6_port)) < 0)
656 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
661 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
662 ntohs(local.in6.sin6_port),
663 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
664 ntohs(remote.in6.sin6_port)) < 0)
675 k = getpeercred(fd, &ucred);
682 (unsigned long) ucred.pid,
683 (unsigned long) ucred.uid) < 0)
690 assert_not_reached("Unhandled socket type.");
697 static void socket_close_fds(Socket *s) {
702 LIST_FOREACH(port, p, s->ports) {
704 p->event_source = sd_event_source_unref(p->event_source);
709 close_nointr_nofail(p->fd);
711 /* One little note: we should never delete any sockets
712 * in the file system here! After all some other
713 * process we spawned might still have a reference of
714 * this fd and wants to continue to use it. Therefore
715 * we delete sockets in the file system before we
716 * create a new one, not after we stopped using
723 static void socket_apply_socket_options(Socket *s, int fd) {
728 int b = s->keep_alive;
729 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
730 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
735 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
736 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
741 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
742 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
747 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
748 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
751 if (s->priority >= 0)
752 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
753 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
755 if (s->receive_buffer > 0) {
756 int value = (int) s->receive_buffer;
758 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
760 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
761 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
762 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
765 if (s->send_buffer > 0) {
766 int value = (int) s->send_buffer;
767 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
768 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
769 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
773 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
774 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
777 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
778 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
780 if (s->ip_ttl >= 0) {
783 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
785 if (socket_ipv6_is_supported())
786 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
789 errno = EAFNOSUPPORT;
793 log_warning_unit(UNIT(s)->id,
794 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
797 if (s->tcp_congestion)
798 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
799 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
802 int b = s->reuse_port;
803 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)) < 0)
804 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
808 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
809 log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
812 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
813 log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
816 static void socket_apply_fifo_options(Socket *s, int fd) {
820 if (s->pipe_size > 0)
821 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
822 log_warning_unit(UNIT(s)->id,
826 if (smack_label_fd(fd, s->smack) < 0)
827 log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
830 static int fifo_address_create(
832 mode_t directory_mode,
843 mkdir_parents_label(path, directory_mode);
845 r = label_context_set(path, S_IFIFO);
849 /* Enforce the right access mode for the fifo */
850 old_mask = umask(~ socket_mode);
852 /* Include the original umask in our mask */
853 umask(~socket_mode | old_mask);
855 r = mkfifo(path, socket_mode);
858 if (r < 0 && errno != EEXIST) {
863 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
868 label_context_clear();
870 if (fstat(fd, &st) < 0) {
875 if (!S_ISFIFO(st.st_mode) ||
876 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
877 st.st_uid != getuid() ||
878 st.st_gid != getgid()) {
888 label_context_clear();
891 close_nointr_nofail(fd);
896 static int special_address_create(
906 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
911 if (fstat(fd, &st) < 0) {
916 /* Check whether this is a /proc, /sys or /dev file or char device */
917 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
927 close_nointr_nofail(fd);
932 static int mq_address_create(
942 struct mq_attr _attr, *attr = NULL;
947 if (maxmsg > 0 && msgsize > 0) {
949 _attr.mq_flags = O_NONBLOCK;
950 _attr.mq_maxmsg = maxmsg;
951 _attr.mq_msgsize = msgsize;
955 /* Enforce the right access mode for the mq */
956 old_mask = umask(~ mq_mode);
958 /* Include the original umask in our mask */
959 umask(~mq_mode | old_mask);
961 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
969 if (fstat(fd, &st) < 0) {
974 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
975 st.st_uid != getuid() ||
976 st.st_gid != getgid()) {
987 close_nointr_nofail(fd);
992 static int socket_open_fds(Socket *s) {
996 bool know_label = false;
1000 LIST_FOREACH(port, p, s->ports) {
1005 if (p->type == SOCKET_SOCKET) {
1009 if ((r = socket_instantiate_service(s)) < 0)
1012 if (UNIT_ISSET(s->service) &&
1013 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1014 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1025 r = socket_address_listen(
1027 SOCK_CLOEXEC|SOCK_NONBLOCK,
1040 socket_apply_socket_options(s, p->fd);
1042 } else if (p->type == SOCKET_SPECIAL) {
1044 r = special_address_create(
1050 } else if (p->type == SOCKET_FIFO) {
1052 r = fifo_address_create(
1060 socket_apply_fifo_options(s, p->fd);
1061 } else if (p->type == SOCKET_MQUEUE) {
1063 r = mq_address_create(
1072 assert_not_reached("Unknown port type");
1079 socket_close_fds(s);
1084 static void socket_unwatch_fds(Socket *s) {
1090 LIST_FOREACH(port, p, s->ports) {
1094 if (p->event_source) {
1095 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_OFF);
1097 log_debug_unit(UNIT(s)->id, "Failed to disable event source.");
1102 static int socket_watch_fds(Socket *s) {
1108 LIST_FOREACH(port, p, s->ports) {
1112 if (p->event_source)
1113 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1115 r = sd_event_add_io(UNIT(s)->manager->event, p->fd, EPOLLIN, socket_dispatch_io, p, &p->event_source);
1118 log_warning_unit(UNIT(s)->id, "Failed to watch listening fds: %s", strerror(-r));
1126 socket_unwatch_fds(s);
1130 static void socket_set_state(Socket *s, SocketState state) {
1131 SocketState old_state;
1134 old_state = s->state;
1137 if (state != SOCKET_START_PRE &&
1138 state != SOCKET_START_POST &&
1139 state != SOCKET_STOP_PRE &&
1140 state != SOCKET_STOP_PRE_SIGTERM &&
1141 state != SOCKET_STOP_PRE_SIGKILL &&
1142 state != SOCKET_STOP_POST &&
1143 state != SOCKET_FINAL_SIGTERM &&
1144 state != SOCKET_FINAL_SIGKILL) {
1146 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1147 socket_unwatch_control_pid(s);
1148 s->control_command = NULL;
1149 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1152 if (state != SOCKET_LISTENING)
1153 socket_unwatch_fds(s);
1155 if (state != SOCKET_START_POST &&
1156 state != SOCKET_LISTENING &&
1157 state != SOCKET_RUNNING &&
1158 state != SOCKET_STOP_PRE &&
1159 state != SOCKET_STOP_PRE_SIGTERM &&
1160 state != SOCKET_STOP_PRE_SIGKILL)
1161 socket_close_fds(s);
1163 if (state != old_state)
1164 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s",
1165 UNIT(s)->id, socket_state_to_string(old_state), socket_state_to_string(state));
1167 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1170 static int socket_coldplug(Unit *u) {
1171 Socket *s = SOCKET(u);
1175 assert(s->state == SOCKET_DEAD);
1177 if (s->deserialized_state == s->state)
1180 if (s->deserialized_state == SOCKET_START_PRE ||
1181 s->deserialized_state == SOCKET_START_POST ||
1182 s->deserialized_state == SOCKET_STOP_PRE ||
1183 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1184 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1185 s->deserialized_state == SOCKET_STOP_POST ||
1186 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1187 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1189 if (s->control_pid <= 0)
1192 r = unit_watch_pid(UNIT(s), s->control_pid);
1196 r = socket_arm_timer(s);
1201 if (s->deserialized_state == SOCKET_START_POST ||
1202 s->deserialized_state == SOCKET_LISTENING ||
1203 s->deserialized_state == SOCKET_RUNNING ||
1204 s->deserialized_state == SOCKET_STOP_PRE ||
1205 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1206 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL) {
1207 r = socket_open_fds(s);
1212 if (s->deserialized_state == SOCKET_LISTENING) {
1213 r = socket_watch_fds(s);
1218 socket_set_state(s, s->deserialized_state);
1222 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1231 unit_realize_cgroup(UNIT(s));
1233 r = unit_setup_exec_runtime(UNIT(s));
1237 r = socket_arm_timer(s);
1241 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1249 UNIT(s)->manager->environment,
1253 UNIT(s)->manager->confirm_spawn,
1254 UNIT(s)->manager->cgroup_supported,
1255 UNIT(s)->cgroup_path,
1266 r = unit_watch_pid(UNIT(s), pid);
1268 /* FIXME: we need to do something here */
1276 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1281 static void socket_enter_dead(Socket *s, SocketResult f) {
1284 if (f != SOCKET_SUCCESS)
1287 exec_runtime_destroy(s->exec_runtime);
1288 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1290 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1293 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1295 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1299 if (f != SOCKET_SUCCESS)
1302 socket_unwatch_control_pid(s);
1304 s->control_command_id = SOCKET_EXEC_STOP_POST;
1306 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1307 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1310 socket_set_state(s, SOCKET_STOP_POST);
1312 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1317 log_warning_unit(UNIT(s)->id,
1318 "%s failed to run 'stop-post' task: %s",
1319 UNIT(s)->id, strerror(-r));
1320 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1323 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1328 if (f != SOCKET_SUCCESS)
1331 r = unit_kill_context(
1334 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1342 r = socket_arm_timer(s);
1346 socket_set_state(s, state);
1347 } else if (state == SOCKET_STOP_PRE_SIGTERM)
1348 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_SUCCESS);
1349 else if (state == SOCKET_STOP_PRE_SIGKILL)
1350 socket_enter_stop_post(s, SOCKET_SUCCESS);
1351 else if (state == SOCKET_FINAL_SIGTERM)
1352 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
1354 socket_enter_dead(s, SOCKET_SUCCESS);
1359 log_warning_unit(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1361 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1362 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1364 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1367 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1371 if (f != SOCKET_SUCCESS)
1374 socket_unwatch_control_pid(s);
1376 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1378 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1379 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1382 socket_set_state(s, SOCKET_STOP_PRE);
1384 socket_enter_stop_post(s, SOCKET_SUCCESS);
1389 log_warning_unit(UNIT(s)->id, "%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1390 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1393 static void socket_enter_listening(Socket *s) {
1397 r = socket_watch_fds(s);
1399 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1403 socket_set_state(s, SOCKET_LISTENING);
1407 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1410 static void socket_enter_start_post(Socket *s) {
1414 r = socket_open_fds(s);
1416 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1420 socket_unwatch_control_pid(s);
1422 s->control_command_id = SOCKET_EXEC_START_POST;
1424 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1425 r = socket_spawn(s, s->control_command, &s->control_pid);
1427 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1431 socket_set_state(s, SOCKET_START_POST);
1433 socket_enter_listening(s);
1438 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1441 static void socket_enter_start_pre(Socket *s) {
1445 socket_unwatch_control_pid(s);
1447 s->control_command_id = SOCKET_EXEC_START_PRE;
1449 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1450 r = socket_spawn(s, s->control_command, &s->control_pid);
1454 socket_set_state(s, SOCKET_START_PRE);
1456 socket_enter_start_post(s);
1461 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1462 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1465 static void socket_enter_running(Socket *s, int cfd) {
1466 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1471 /* We don't take connections anymore if we are supposed to
1472 * shut down anyway */
1473 if (unit_stop_pending(UNIT(s))) {
1475 log_debug_unit(UNIT(s)->id, "Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1478 close_nointr_nofail(cfd);
1480 /* Flush all sockets by closing and reopening them */
1481 socket_close_fds(s);
1483 r = socket_open_fds(s);
1485 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1486 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1490 r = socket_watch_fds(s);
1492 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1493 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1503 bool pending = false;
1505 /* If there's already a start pending don't bother to
1507 SET_FOREACH(other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1508 if (unit_active_or_pending(other)) {
1514 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1519 socket_set_state(s, SOCKET_RUNNING);
1521 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1524 if (s->n_connections >= s->max_connections) {
1525 log_warning_unit(UNIT(s)->id, "%s: Too many incoming connections (%u)", UNIT(s)->id, s->n_connections);
1526 close_nointr_nofail(cfd);
1530 r = socket_instantiate_service(s);
1534 r = instance_from_socket(cfd, s->n_accepted, &instance);
1539 /* ENOTCONN is legitimate if TCP RST was received.
1540 * This connection is over, but the socket unit lives on. */
1541 close_nointr_nofail(cfd);
1545 prefix = unit_name_to_prefix(UNIT(s)->id);
1551 name = unit_name_build(prefix, instance, ".service");
1557 r = unit_add_name(UNIT_DEREF(s->service), name);
1561 service = SERVICE(UNIT_DEREF(s->service));
1562 unit_ref_unset(&s->service);
1565 UNIT(service)->no_gc = false;
1567 unit_choose_id(UNIT(service), name);
1569 r = service_set_socket_fd(service, cfd, s);
1574 s->n_connections ++;
1576 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1580 /* Notify clients about changed counters */
1581 unit_add_to_dbus_queue(UNIT(s));
1587 log_warning_unit(UNIT(s)->id, "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1588 UNIT(s)->id, cfd >= 0 ? "template" : "non-template",
1589 bus_error_message(&error, r));
1591 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1594 close_nointr_nofail(cfd);
1597 static void socket_run_next(Socket *s) {
1601 assert(s->control_command);
1602 assert(s->control_command->command_next);
1604 socket_unwatch_control_pid(s);
1606 s->control_command = s->control_command->command_next;
1608 r = socket_spawn(s, s->control_command, &s->control_pid);
1615 log_warning_unit(UNIT(s)->id, "%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1617 if (s->state == SOCKET_START_POST)
1618 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1619 else if (s->state == SOCKET_STOP_POST)
1620 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1622 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1625 static int socket_start(Unit *u) {
1626 Socket *s = SOCKET(u);
1630 /* We cannot fulfill this request right now, try again later
1632 if (s->state == SOCKET_STOP_PRE ||
1633 s->state == SOCKET_STOP_PRE_SIGKILL ||
1634 s->state == SOCKET_STOP_PRE_SIGTERM ||
1635 s->state == SOCKET_STOP_POST ||
1636 s->state == SOCKET_FINAL_SIGTERM ||
1637 s->state == SOCKET_FINAL_SIGKILL)
1640 if (s->state == SOCKET_START_PRE ||
1641 s->state == SOCKET_START_POST)
1644 /* Cannot run this without the service being around */
1645 if (UNIT_ISSET(s->service)) {
1648 service = SERVICE(UNIT_DEREF(s->service));
1650 if (UNIT(service)->load_state != UNIT_LOADED) {
1651 log_error_unit(u->id, "Socket service %s not loaded, refusing.", UNIT(service)->id);
1655 /* If the service is already active we cannot start the
1657 if (service->state != SERVICE_DEAD &&
1658 service->state != SERVICE_FAILED &&
1659 service->state != SERVICE_AUTO_RESTART) {
1660 log_error_unit(u->id, "Socket service %s already active, refusing.", UNIT(service)->id);
1664 #ifdef HAVE_SYSV_COMPAT
1665 if (service->is_sysv) {
1666 log_error_unit(u->id,
1667 "Using SysV services for socket activation is not supported. Refusing.");
1673 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1675 s->result = SOCKET_SUCCESS;
1676 socket_enter_start_pre(s);
1681 static int socket_stop(Unit *u) {
1682 Socket *s = SOCKET(u);
1687 if (s->state == SOCKET_STOP_PRE ||
1688 s->state == SOCKET_STOP_PRE_SIGTERM ||
1689 s->state == SOCKET_STOP_PRE_SIGKILL ||
1690 s->state == SOCKET_STOP_POST ||
1691 s->state == SOCKET_FINAL_SIGTERM ||
1692 s->state == SOCKET_FINAL_SIGKILL)
1695 /* If there's already something running we go directly into
1697 if (s->state == SOCKET_START_PRE ||
1698 s->state == SOCKET_START_POST) {
1699 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1703 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1705 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1709 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1710 Socket *s = SOCKET(u);
1718 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1719 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1720 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1722 if (s->control_pid > 0)
1723 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1725 if (s->control_command_id >= 0)
1726 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1728 LIST_FOREACH(port, p, s->ports) {
1734 copy = fdset_put_dup(fds, p->fd);
1738 if (p->type == SOCKET_SOCKET) {
1739 _cleanup_free_ char *t = NULL;
1741 r = socket_address_print(&p->address, &t);
1745 if (socket_address_family(&p->address) == AF_NETLINK)
1746 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1748 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1750 } else if (p->type == SOCKET_SPECIAL)
1751 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1752 else if (p->type == SOCKET_MQUEUE)
1753 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1755 assert(p->type == SOCKET_FIFO);
1756 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1763 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1764 Socket *s = SOCKET(u);
1770 if (streq(key, "state")) {
1773 state = socket_state_from_string(value);
1775 log_debug_unit(u->id, "Failed to parse state value %s", value);
1777 s->deserialized_state = state;
1778 } else if (streq(key, "result")) {
1781 f = socket_result_from_string(value);
1783 log_debug_unit(u->id, "Failed to parse result value %s", value);
1784 else if (f != SOCKET_SUCCESS)
1787 } else if (streq(key, "n-accepted")) {
1790 if (safe_atou(value, &k) < 0)
1791 log_debug_unit(u->id, "Failed to parse n-accepted value %s", value);
1794 } else if (streq(key, "control-pid")) {
1797 if (parse_pid(value, &pid) < 0)
1798 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1800 s->control_pid = pid;
1801 } else if (streq(key, "control-command")) {
1802 SocketExecCommand id;
1804 id = socket_exec_command_from_string(value);
1806 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1808 s->control_command_id = id;
1809 s->control_command = s->exec_command[id];
1811 } else if (streq(key, "fifo")) {
1815 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1816 log_debug_unit(u->id, "Failed to parse fifo value %s", value);
1819 LIST_FOREACH(port, p, s->ports)
1820 if (p->type == SOCKET_FIFO &&
1821 streq_ptr(p->path, value+skip))
1826 close_nointr_nofail(p->fd);
1827 p->fd = fdset_remove(fds, fd);
1831 } else if (streq(key, "special")) {
1835 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1836 log_debug_unit(u->id, "Failed to parse special value %s", value);
1839 LIST_FOREACH(port, p, s->ports)
1840 if (p->type == SOCKET_SPECIAL &&
1841 streq_ptr(p->path, value+skip))
1846 close_nointr_nofail(p->fd);
1847 p->fd = fdset_remove(fds, fd);
1851 } else if (streq(key, "mqueue")) {
1855 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1856 log_debug_unit(u->id, "Failed to parse mqueue value %s", value);
1859 LIST_FOREACH(port, p, s->ports)
1860 if (p->type == SOCKET_MQUEUE &&
1861 streq_ptr(p->path, value+skip))
1866 close_nointr_nofail(p->fd);
1867 p->fd = fdset_remove(fds, fd);
1871 } else if (streq(key, "socket")) {
1872 int fd, type, skip = 0;
1875 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1876 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1879 LIST_FOREACH(port, p, s->ports)
1880 if (socket_address_is(&p->address, value+skip, type))
1885 close_nointr_nofail(p->fd);
1886 p->fd = fdset_remove(fds, fd);
1890 } else if (streq(key, "netlink")) {
1894 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1895 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1898 LIST_FOREACH(port, p, s->ports)
1899 if (socket_address_is_netlink(&p->address, value+skip))
1904 close_nointr_nofail(p->fd);
1905 p->fd = fdset_remove(fds, fd);
1909 log_debug_unit(UNIT(s)->id, "Unknown serialization key '%s'", key);
1914 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1915 Socket *s = SOCKET(u);
1920 LIST_FOREACH(port, p, s->ports) {
1924 if (p->type != SOCKET_SOCKET)
1930 FDSET_FOREACH(fd, fds, i) {
1931 if (socket_address_matches_fd(&p->address, fd)) {
1932 p->fd = fdset_remove(fds, fd);
1933 s->deserialized_state = SOCKET_LISTENING;
1942 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1945 return state_translation_table[SOCKET(u)->state];
1948 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1951 return socket_state_to_string(SOCKET(u)->state);
1954 const char* socket_port_type_to_string(SocketPort *p) {
1962 switch (p->address.type) {
1970 case SOCK_SEQPACKET:
1971 return "SequentialPacket";
1974 if (socket_address_family(&p->address) == AF_NETLINK)
1981 case SOCKET_SPECIAL:
1985 return "MessageQueue";
1995 _pure_ static bool socket_check_gc(Unit *u) {
1996 Socket *s = SOCKET(u);
2000 return s->n_connections > 0;
2003 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2004 SocketPort *p = userdata;
2010 if (p->socket->state != SOCKET_LISTENING)
2013 log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
2015 if (revents != EPOLLIN) {
2017 if (revents & EPOLLHUP)
2018 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.",
2019 UNIT(p->socket)->id);
2021 log_error_unit(UNIT(p->socket)->id, "%s: Got unexpected poll event (0x%x) on socket.",
2022 UNIT(p->socket)->id, revents);
2027 if (p->socket->accept &&
2028 p->type == SOCKET_SOCKET &&
2029 socket_address_can_accept(&p->address)) {
2033 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2039 log_error_unit(UNIT(p->socket)->id,
2040 "Failed to accept socket: %m");
2047 socket_apply_socket_options(p->socket, cfd);
2050 socket_enter_running(p->socket, cfd);
2054 socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2058 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2059 Socket *s = SOCKET(u);
2065 if (pid != s->control_pid)
2070 if (is_clean_exit(code, status, NULL))
2072 else if (code == CLD_EXITED)
2073 f = SOCKET_FAILURE_EXIT_CODE;
2074 else if (code == CLD_KILLED)
2075 f = SOCKET_FAILURE_SIGNAL;
2076 else if (code == CLD_DUMPED)
2077 f = SOCKET_FAILURE_CORE_DUMP;
2079 assert_not_reached("Unknown code");
2081 if (s->control_command) {
2082 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2084 if (s->control_command->ignore)
2088 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2090 "%s control process exited, code=%s status=%i",
2091 u->id, sigchld_code_to_string(code), status);
2093 if (f != SOCKET_SUCCESS)
2096 if (s->control_command &&
2097 s->control_command->command_next &&
2098 f == SOCKET_SUCCESS) {
2100 log_debug_unit(u->id,
2101 "%s running next command for state %s",
2102 u->id, socket_state_to_string(s->state));
2105 s->control_command = NULL;
2106 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2108 /* No further commands for this step, so let's figure
2109 * out what to do next */
2111 log_debug_unit(u->id,
2112 "%s got final SIGCHLD for state %s",
2113 u->id, socket_state_to_string(s->state));
2117 case SOCKET_START_PRE:
2118 if (f == SOCKET_SUCCESS)
2119 socket_enter_start_post(s);
2121 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2124 case SOCKET_START_POST:
2125 if (f == SOCKET_SUCCESS)
2126 socket_enter_listening(s);
2128 socket_enter_stop_pre(s, f);
2131 case SOCKET_STOP_PRE:
2132 case SOCKET_STOP_PRE_SIGTERM:
2133 case SOCKET_STOP_PRE_SIGKILL:
2134 socket_enter_stop_post(s, f);
2137 case SOCKET_STOP_POST:
2138 case SOCKET_FINAL_SIGTERM:
2139 case SOCKET_FINAL_SIGKILL:
2140 socket_enter_dead(s, f);
2144 assert_not_reached("Uh, control process died at wrong time.");
2148 /* Notify clients about changed exit status */
2149 unit_add_to_dbus_queue(u);
2152 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2153 Socket *s = SOCKET(userdata);
2156 assert(s->timer_event_source == source);
2160 case SOCKET_START_PRE:
2161 log_warning_unit(UNIT(s)->id,
2162 "%s starting timed out. Terminating.", UNIT(s)->id);
2163 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2166 case SOCKET_START_POST:
2167 log_warning_unit(UNIT(s)->id,
2168 "%s starting timed out. Stopping.", UNIT(s)->id);
2169 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2172 case SOCKET_STOP_PRE:
2173 log_warning_unit(UNIT(s)->id,
2174 "%s stopping timed out. Terminating.", UNIT(s)->id);
2175 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2178 case SOCKET_STOP_PRE_SIGTERM:
2179 if (s->kill_context.send_sigkill) {
2180 log_warning_unit(UNIT(s)->id,
2181 "%s stopping timed out. Killing.", UNIT(s)->id);
2182 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2184 log_warning_unit(UNIT(s)->id,
2185 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2187 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2191 case SOCKET_STOP_PRE_SIGKILL:
2192 log_warning_unit(UNIT(s)->id,
2193 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2194 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2197 case SOCKET_STOP_POST:
2198 log_warning_unit(UNIT(s)->id,
2199 "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2200 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2203 case SOCKET_FINAL_SIGTERM:
2204 if (s->kill_context.send_sigkill) {
2205 log_warning_unit(UNIT(s)->id,
2206 "%s stopping timed out (2). Killing.", UNIT(s)->id);
2207 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2209 log_warning_unit(UNIT(s)->id,
2210 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2212 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2216 case SOCKET_FINAL_SIGKILL:
2217 log_warning_unit(UNIT(s)->id,
2218 "%s still around after SIGKILL (2). Entering failed mode.",
2220 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2224 assert_not_reached("Timeout at wrong time.");
2230 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2239 /* Called from the service code for requesting our fds */
2242 LIST_FOREACH(port, p, s->ports)
2252 if (!(rfds = new(int, rn_fds)))
2256 LIST_FOREACH(port, p, s->ports)
2260 assert(k == rn_fds);
2268 static void socket_reset_failed(Unit *u) {
2269 Socket *s = SOCKET(u);
2273 if (s->state == SOCKET_FAILED)
2274 socket_set_state(s, SOCKET_DEAD);
2276 s->result = SOCKET_SUCCESS;
2279 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2282 /* The service is dead. Dang!
2284 * This is strictly for one-instance-for-all-connections
2287 if (s->state == SOCKET_RUNNING) {
2288 log_debug_unit(UNIT(s)->id, "%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2289 if (failed_permanent)
2290 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2292 socket_enter_listening(s);
2296 void socket_connection_unref(Socket *s) {
2299 /* The service is dead. Yay!
2301 * This is strictly for one-instance-per-connection
2304 assert(s->n_connections > 0);
2307 log_debug_unit(UNIT(s)->id, "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2310 static void socket_trigger_notify(Unit *u, Unit *other) {
2311 Socket *s = SOCKET(u);
2317 /* Don't propagate state changes from the service if we are
2318 already down or accepting connections */
2319 if ((s->state != SOCKET_RUNNING &&
2320 s->state != SOCKET_LISTENING) ||
2324 if (other->load_state != UNIT_LOADED ||
2325 other->type != UNIT_SERVICE)
2328 se = SERVICE(other);
2330 if (se->state == SERVICE_FAILED)
2331 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2333 if (se->state == SERVICE_DEAD ||
2334 se->state == SERVICE_STOP ||
2335 se->state == SERVICE_STOP_SIGTERM ||
2336 se->state == SERVICE_STOP_SIGKILL ||
2337 se->state == SERVICE_STOP_POST ||
2338 se->state == SERVICE_FINAL_SIGTERM ||
2339 se->state == SERVICE_FINAL_SIGKILL ||
2340 se->state == SERVICE_AUTO_RESTART)
2341 socket_notify_service_dead(s, false);
2343 if (se->state == SERVICE_RUNNING)
2344 socket_set_state(s, SOCKET_RUNNING);
2347 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2348 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2351 static int socket_get_timeout(Unit *u, uint64_t *timeout) {
2352 Socket *s = SOCKET(u);
2355 if (!s->timer_event_source)
2358 r = sd_event_source_get_time(s->timer_event_source, timeout);
2365 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2366 [SOCKET_DEAD] = "dead",
2367 [SOCKET_START_PRE] = "start-pre",
2368 [SOCKET_START_POST] = "start-post",
2369 [SOCKET_LISTENING] = "listening",
2370 [SOCKET_RUNNING] = "running",
2371 [SOCKET_STOP_PRE] = "stop-pre",
2372 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2373 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2374 [SOCKET_STOP_POST] = "stop-post",
2375 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2376 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2377 [SOCKET_FAILED] = "failed"
2380 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2382 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2383 [SOCKET_EXEC_START_PRE] = "StartPre",
2384 [SOCKET_EXEC_START_POST] = "StartPost",
2385 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2386 [SOCKET_EXEC_STOP_POST] = "StopPost"
2389 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2391 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2392 [SOCKET_SUCCESS] = "success",
2393 [SOCKET_FAILURE_RESOURCES] = "resources",
2394 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2395 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2396 [SOCKET_FAILURE_SIGNAL] = "signal",
2397 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2398 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2401 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2403 const UnitVTable socket_vtable = {
2404 .object_size = sizeof(Socket),
2405 .exec_context_offset = offsetof(Socket, exec_context),
2406 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2407 .kill_context_offset = offsetof(Socket, kill_context),
2408 .exec_runtime_offset = offsetof(Socket, exec_runtime),
2414 .private_section = "Socket",
2416 .init = socket_init,
2417 .done = socket_done,
2418 .load = socket_load,
2420 .coldplug = socket_coldplug,
2422 .dump = socket_dump,
2424 .start = socket_start,
2425 .stop = socket_stop,
2427 .kill = socket_kill,
2429 .get_timeout = socket_get_timeout,
2431 .serialize = socket_serialize,
2432 .deserialize_item = socket_deserialize_item,
2433 .distribute_fds = socket_distribute_fds,
2435 .active_state = socket_active_state,
2436 .sub_state_to_string = socket_sub_state_to_string,
2438 .check_gc = socket_check_gc,
2440 .sigchld_event = socket_sigchld_event,
2442 .trigger_notify = socket_trigger_notify,
2444 .reset_failed = socket_reset_failed,
2446 .bus_interface = "org.freedesktop.systemd1.Socket",
2447 .bus_vtable = bus_socket_vtable,
2448 .bus_set_property = bus_socket_set_property,
2449 .bus_commit_properties = bus_socket_commit_properties,
2451 .status_message_formats = {
2452 /*.starting_stopping = {
2453 [0] = "Starting socket %s...",
2454 [1] = "Stopping socket %s...",
2456 .finished_start_job = {
2457 [JOB_DONE] = "Listening on %s.",
2458 [JOB_FAILED] = "Failed to listen on %s.",
2459 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2460 [JOB_TIMEOUT] = "Timed out starting %s.",
2462 .finished_stop_job = {
2463 [JOB_DONE] = "Closed %s.",
2464 [JOB_FAILED] = "Failed stopping %s.",
2465 [JOB_TIMEOUT] = "Timed out stopping %s.",