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>
32 #include <sys/xattr.h>
36 #include "load-dropin.h"
37 #include "load-fragment.h"
40 #include "path-util.h"
41 #include "unit-name.h"
42 #include "unit-printf.h"
46 #include "exit-status.h"
48 #include "smack-util.h"
50 #include "bus-error.h"
51 #include "dbus-socket.h"
55 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
56 [SOCKET_DEAD] = UNIT_INACTIVE,
57 [SOCKET_START_PRE] = UNIT_ACTIVATING,
58 [SOCKET_START_POST] = UNIT_ACTIVATING,
59 [SOCKET_LISTENING] = UNIT_ACTIVE,
60 [SOCKET_RUNNING] = UNIT_ACTIVE,
61 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
62 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
63 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
64 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
65 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
66 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
67 [SOCKET_FAILED] = UNIT_FAILED
70 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
71 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
73 static void socket_init(Unit *u) {
74 Socket *s = SOCKET(u);
77 assert(u->load_state == UNIT_STUB);
79 s->backlog = SOMAXCONN;
80 s->timeout_usec = u->manager->default_timeout_start_usec;
81 s->directory_mode = 0755;
82 s->socket_mode = 0666;
84 s->max_connections = 64;
91 s->exec_context.std_output = u->manager->default_std_output;
92 s->exec_context.std_error = u->manager->default_std_error;
94 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
97 static void socket_unwatch_control_pid(Socket *s) {
100 if (s->control_pid <= 0)
103 unit_unwatch_pid(UNIT(s), s->control_pid);
107 void socket_free_ports(Socket *s) {
112 while ((p = s->ports)) {
113 LIST_REMOVE(port, s->ports, p);
115 sd_event_source_unref(p->event_source);
123 static void socket_done(Unit *u) {
124 Socket *s = SOCKET(u);
128 socket_free_ports(s);
130 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
131 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
132 s->control_command = NULL;
134 socket_unwatch_control_pid(s);
136 unit_ref_unset(&s->service);
138 free(s->tcp_congestion);
139 s->tcp_congestion = NULL;
141 free(s->bind_to_device);
142 s->bind_to_device = NULL;
145 free(s->smack_ip_in);
146 free(s->smack_ip_out);
148 strv_free(s->symlinks);
150 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
153 static int socket_arm_timer(Socket *s) {
158 if (s->timeout_usec <= 0) {
159 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
163 if (s->timer_event_source) {
164 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec);
168 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
171 return sd_event_add_time(
172 UNIT(s)->manager->event,
173 &s->timer_event_source,
175 now(CLOCK_MONOTONIC) + s->timeout_usec, 0,
176 socket_dispatch_timer, s);
179 static int socket_instantiate_service(Socket *s) {
180 _cleanup_free_ char *prefix = NULL;
181 _cleanup_free_ char *name = NULL;
187 /* This fills in s->service if it isn't filled in yet. For
188 * Accept=yes sockets we create the next connection service
189 * here. For Accept=no this is mostly a NOP since the service
190 * is figured out at load time anyway. */
192 if (UNIT_DEREF(s->service))
197 prefix = unit_name_to_prefix(UNIT(s)->id);
201 if (asprintf(&name, "%s@%u.service", prefix, s->n_accepted) < 0)
204 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
208 #ifdef HAVE_SYSV_COMPAT
209 if (SERVICE(u)->is_sysv) {
210 log_error("Using SysV services for socket activation is not supported. Refusing.");
216 unit_ref_set(&s->service, u);
218 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
221 static bool have_non_accept_socket(Socket *s) {
229 LIST_FOREACH(port, p, s->ports) {
231 if (p->type != SOCKET_SOCKET)
234 if (!socket_address_can_accept(&p->address))
241 static int socket_add_mount_links(Socket *s) {
247 LIST_FOREACH(port, p, s->ports) {
248 const char *path = NULL;
250 if (p->type == SOCKET_SOCKET)
251 path = socket_address_get_path(&p->address);
252 else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL)
258 r = unit_require_mounts_for(UNIT(s), path);
266 static int socket_add_device_link(Socket *s) {
271 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
274 t = strappenda("/sys/subsystem/net/devices/", s->bind_to_device);
275 return unit_add_node_link(UNIT(s), t, false);
278 static int socket_add_default_dependencies(Socket *s) {
282 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
286 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
287 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
292 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
295 _pure_ static bool socket_has_exec(Socket *s) {
299 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
300 if (s->exec_command[i])
306 static int socket_add_extras(Socket *s) {
312 if (have_non_accept_socket(s)) {
314 if (!UNIT_DEREF(s->service)) {
317 r = unit_load_related_unit(u, ".service", &x);
321 unit_ref_set(&s->service, x);
324 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
329 r = socket_add_mount_links(s);
333 r = socket_add_device_link(s);
337 r = unit_patch_contexts(u);
341 if (socket_has_exec(s)) {
342 r = unit_add_exec_dependencies(u, &s->exec_context);
346 r = unit_add_default_slice(u, &s->cgroup_context);
351 if (u->default_dependencies) {
352 r = socket_add_default_dependencies(s);
360 static const char *socket_find_symlink_target(Socket *s) {
361 const char *found = NULL;
364 LIST_FOREACH(port, p, s->ports) {
365 const char *f = NULL;
374 if (p->address.sockaddr.un.sun_path[0] != 0)
375 f = p->address.sockaddr.un.sun_path;
393 static int socket_verify(Socket *s) {
396 if (UNIT(s)->load_state != UNIT_LOADED)
400 log_error_unit(UNIT(s)->id, "%s lacks Listen setting. Refusing.", UNIT(s)->id);
404 if (s->accept && have_non_accept_socket(s)) {
405 log_error_unit(UNIT(s)->id, "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
410 if (s->accept && s->max_connections <= 0) {
411 log_error_unit(UNIT(s)->id, "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
415 if (s->accept && UNIT_DEREF(s->service)) {
416 log_error_unit(UNIT(s)->id, "Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
420 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
421 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
425 if (!strv_isempty(s->symlinks) && !socket_find_symlink_target(s)) {
426 log_error_unit(UNIT(s)->id, "%s has symlinks set but none or more than one node in the file system. Refusing.", UNIT(s)->id);
433 static int socket_load(Unit *u) {
434 Socket *s = SOCKET(u);
438 assert(u->load_state == UNIT_STUB);
440 r = unit_load_fragment_and_dropin(u);
444 if (u->load_state == UNIT_LOADED) {
445 /* This is a new unit? Then let's add in some extras */
446 r = socket_add_extras(s);
451 return socket_verify(s);
454 _const_ static const char* listen_lookup(int family, int type) {
456 if (family == AF_NETLINK)
457 return "ListenNetlink";
459 if (type == SOCK_STREAM)
460 return "ListenStream";
461 else if (type == SOCK_DGRAM)
462 return "ListenDatagram";
463 else if (type == SOCK_SEQPACKET)
464 return "ListenSequentialPacket";
466 assert_not_reached("Unknown socket type");
470 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
472 Socket *s = SOCKET(u);
479 prefix2 = strappenda(prefix, "\t");
482 "%sSocket State: %s\n"
484 "%sBindIPv6Only: %s\n"
486 "%sSocketMode: %04o\n"
487 "%sDirectoryMode: %04o\n"
490 "%sTransparent: %s\n"
492 "%sPassCredentials: %s\n"
493 "%sPassSecurity: %s\n"
494 "%sTCPCongestion: %s\n"
495 "%sRemoveOnStop: %s\n",
496 prefix, socket_state_to_string(s->state),
497 prefix, socket_result_to_string(s->result),
498 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
500 prefix, s->socket_mode,
501 prefix, s->directory_mode,
502 prefix, yes_no(s->keep_alive),
503 prefix, yes_no(s->free_bind),
504 prefix, yes_no(s->transparent),
505 prefix, yes_no(s->broadcast),
506 prefix, yes_no(s->pass_cred),
507 prefix, yes_no(s->pass_sec),
508 prefix, strna(s->tcp_congestion),
509 prefix, yes_no(s->remove_on_stop));
511 if (s->control_pid > 0)
513 "%sControl PID: "PID_FMT"\n",
514 prefix, s->control_pid);
516 if (s->bind_to_device)
518 "%sBindToDevice: %s\n",
519 prefix, s->bind_to_device);
524 "%sNConnections: %u\n"
525 "%sMaxConnections: %u\n",
526 prefix, s->n_accepted,
527 prefix, s->n_connections,
528 prefix, s->max_connections);
530 if (s->priority >= 0)
533 prefix, s->priority);
535 if (s->receive_buffer > 0)
537 "%sReceiveBuffer: %zu\n",
538 prefix, s->receive_buffer);
540 if (s->send_buffer > 0)
542 "%sSendBuffer: %zu\n",
543 prefix, s->send_buffer);
555 if (s->pipe_size > 0)
558 prefix, s->pipe_size);
565 if (s->mq_maxmsg > 0)
567 "%sMessageQueueMaxMessages: %li\n",
568 prefix, s->mq_maxmsg);
570 if (s->mq_msgsize > 0)
572 "%sMessageQueueMessageSize: %li\n",
573 prefix, s->mq_msgsize);
578 prefix, yes_no(s->reuse_port));
582 "%sSmackLabel: %s\n",
587 "%sSmackLabelIPIn: %s\n",
588 prefix, s->smack_ip_in);
592 "%sSmackLabelIPOut: %s\n",
593 prefix, s->smack_ip_out);
595 LIST_FOREACH(port, p, s->ports) {
597 if (p->type == SOCKET_SOCKET) {
602 if ((r = socket_address_print(&p->address, &k)) < 0)
607 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
609 } else if (p->type == SOCKET_SPECIAL)
610 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
611 else if (p->type == SOCKET_MQUEUE)
612 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
614 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
617 exec_context_dump(&s->exec_context, f, prefix);
618 kill_context_dump(&s->kill_context, f, prefix);
620 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
621 if (!s->exec_command[c])
624 fprintf(f, "%s-> %s:\n",
625 prefix, socket_exec_command_to_string(c));
627 exec_command_dump_list(s->exec_command[c], f, prefix2);
631 static int instance_from_socket(int fd, unsigned nr, char **instance) {
634 union sockaddr_union local, remote;
640 if (getsockname(fd, &local.sa, &l) < 0)
644 if (getpeername(fd, &remote.sa, &l) < 0)
647 switch (local.sa.sa_family) {
651 a = ntohl(local.in.sin_addr.s_addr),
652 b = ntohl(remote.in.sin_addr.s_addr);
655 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
657 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
658 ntohs(local.in.sin_port),
659 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
660 ntohs(remote.in.sin_port)) < 0)
667 static const unsigned char ipv4_prefix[] = {
668 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
671 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
672 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
674 *a = local.in6.sin6_addr.s6_addr+12,
675 *b = remote.in6.sin6_addr.s6_addr+12;
678 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
680 a[0], a[1], a[2], a[3],
681 ntohs(local.in6.sin6_port),
682 b[0], b[1], b[2], b[3],
683 ntohs(remote.in6.sin6_port)) < 0)
686 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
691 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
692 ntohs(local.in6.sin6_port),
693 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
694 ntohs(remote.in6.sin6_port)) < 0)
705 k = getpeercred(fd, &ucred);
708 "%u-"PID_FMT"-"UID_FMT,
709 nr, ucred.pid, ucred.uid) < 0)
711 } else if (k == -ENODATA) {
712 /* This handles the case where somebody is
713 * connecting from another pid/uid namespace
714 * (e.g. from outside of our container). */
726 assert_not_reached("Unhandled socket type.");
733 static void socket_close_fds(Socket *s) {
739 LIST_FOREACH(port, p, s->ports) {
741 p->event_source = sd_event_source_unref(p->event_source);
746 p->fd = safe_close(p->fd);
748 /* One little note: we should normally not delete any
749 * sockets in the file system here! After all some
750 * other process we spawned might still have a
751 * reference of this fd and wants to continue to use
752 * it. Therefore we delete sockets in the file system
753 * before we create a new one, not after we stopped
756 if (s->remove_on_stop) {
768 socket_address_unlink(&p->address);
777 if (s->remove_on_stop)
778 STRV_FOREACH(i, s->symlinks)
782 static void socket_apply_socket_options(Socket *s, int fd) {
787 int b = s->keep_alive;
788 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
789 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
794 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
795 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
800 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
801 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
806 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
807 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
810 if (s->priority >= 0)
811 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
812 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
814 if (s->receive_buffer > 0) {
815 int value = (int) s->receive_buffer;
817 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
819 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
820 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
821 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
824 if (s->send_buffer > 0) {
825 int value = (int) s->send_buffer;
826 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
827 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
828 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
832 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
833 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
836 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
837 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
839 if (s->ip_ttl >= 0) {
842 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
844 if (socket_ipv6_is_supported())
845 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
848 errno = EAFNOSUPPORT;
852 log_warning_unit(UNIT(s)->id,
853 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
856 if (s->tcp_congestion)
857 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
858 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
861 int b = s->reuse_port;
862 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)) < 0)
863 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
867 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
868 log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
871 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
872 log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
875 static void socket_apply_fifo_options(Socket *s, int fd) {
879 if (s->pipe_size > 0)
880 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
881 log_warning_unit(UNIT(s)->id,
885 if (smack_label_fd(fd, s->smack) < 0)
886 log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
889 static int fifo_address_create(
891 mode_t directory_mode,
902 mkdir_parents_label(path, directory_mode);
904 r = label_context_set(path, S_IFIFO);
908 /* Enforce the right access mode for the fifo */
909 old_mask = umask(~ socket_mode);
911 /* Include the original umask in our mask */
912 umask(~socket_mode | old_mask);
914 r = mkfifo(path, socket_mode);
917 if (r < 0 && errno != EEXIST) {
922 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
927 label_context_clear();
929 if (fstat(fd, &st) < 0) {
934 if (!S_ISFIFO(st.st_mode) ||
935 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
936 st.st_uid != getuid() ||
937 st.st_gid != getgid()) {
947 label_context_clear();
953 static int special_address_create(
963 fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW);
969 if (fstat(fd, &st) < 0) {
974 /* Check whether this is a /proc, /sys or /dev file or char device */
975 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
989 static int mq_address_create(
999 struct mq_attr _attr, *attr = NULL;
1004 if (maxmsg > 0 && msgsize > 0) {
1006 _attr.mq_flags = O_NONBLOCK;
1007 _attr.mq_maxmsg = maxmsg;
1008 _attr.mq_msgsize = msgsize;
1012 /* Enforce the right access mode for the mq */
1013 old_mask = umask(~ mq_mode);
1015 /* Include the original umask in our mask */
1016 umask(~mq_mode | old_mask);
1017 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
1025 if (fstat(fd, &st) < 0) {
1030 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
1031 st.st_uid != getuid() ||
1032 st.st_gid != getgid()) {
1046 static int socket_symlink(Socket *s) {
1052 p = socket_find_symlink_target(s);
1056 STRV_FOREACH(i, s->symlinks)
1062 static int socket_open_fds(Socket *s) {
1066 bool know_label = false;
1070 LIST_FOREACH(port, p, s->ports) {
1075 if (p->type == SOCKET_SOCKET) {
1079 r = socket_instantiate_service(s);
1083 if (UNIT_ISSET(s->service) &&
1084 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1085 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1086 if (r < 0 && r != -EPERM)
1093 r = socket_address_listen(
1095 SOCK_CLOEXEC|SOCK_NONBLOCK,
1108 socket_apply_socket_options(s, p->fd);
1111 } else if (p->type == SOCKET_SPECIAL) {
1113 r = special_address_create(
1119 } else if (p->type == SOCKET_FIFO) {
1121 r = fifo_address_create(
1129 socket_apply_fifo_options(s, p->fd);
1132 } else if (p->type == SOCKET_MQUEUE) {
1134 r = mq_address_create(
1143 assert_not_reached("Unknown port type");
1150 socket_close_fds(s);
1155 static void socket_unwatch_fds(Socket *s) {
1161 LIST_FOREACH(port, p, s->ports) {
1165 if (p->event_source) {
1166 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_OFF);
1168 log_debug_unit(UNIT(s)->id, "Failed to disable event source.");
1173 static int socket_watch_fds(Socket *s) {
1179 LIST_FOREACH(port, p, s->ports) {
1183 if (p->event_source)
1184 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1186 r = sd_event_add_io(UNIT(s)->manager->event, &p->event_source, p->fd, EPOLLIN, socket_dispatch_io, p);
1189 log_warning_unit(UNIT(s)->id, "Failed to watch listening fds: %s", strerror(-r));
1197 socket_unwatch_fds(s);
1201 static void socket_set_state(Socket *s, SocketState state) {
1202 SocketState old_state;
1205 old_state = s->state;
1212 SOCKET_STOP_PRE_SIGTERM,
1213 SOCKET_STOP_PRE_SIGKILL,
1215 SOCKET_FINAL_SIGTERM,
1216 SOCKET_FINAL_SIGKILL)) {
1218 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1219 socket_unwatch_control_pid(s);
1220 s->control_command = NULL;
1221 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1224 if (state != SOCKET_LISTENING)
1225 socket_unwatch_fds(s);
1232 SOCKET_STOP_PRE_SIGTERM,
1233 SOCKET_STOP_PRE_SIGKILL))
1234 socket_close_fds(s);
1236 if (state != old_state)
1237 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s",
1238 UNIT(s)->id, socket_state_to_string(old_state), socket_state_to_string(state));
1240 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1243 static int socket_coldplug(Unit *u) {
1244 Socket *s = SOCKET(u);
1248 assert(s->state == SOCKET_DEAD);
1250 if (s->deserialized_state == s->state)
1253 if (s->deserialized_state == SOCKET_START_PRE ||
1254 s->deserialized_state == SOCKET_START_POST ||
1255 s->deserialized_state == SOCKET_STOP_PRE ||
1256 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1257 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1258 s->deserialized_state == SOCKET_STOP_POST ||
1259 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1260 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1262 if (s->control_pid <= 0)
1265 r = unit_watch_pid(UNIT(s), s->control_pid);
1269 r = socket_arm_timer(s);
1274 if (s->deserialized_state == SOCKET_START_POST ||
1275 s->deserialized_state == SOCKET_LISTENING ||
1276 s->deserialized_state == SOCKET_RUNNING ||
1277 s->deserialized_state == SOCKET_STOP_PRE ||
1278 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1279 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL) {
1280 r = socket_open_fds(s);
1285 if (s->deserialized_state == SOCKET_LISTENING) {
1286 r = socket_watch_fds(s);
1291 socket_set_state(s, s->deserialized_state);
1295 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1304 unit_realize_cgroup(UNIT(s));
1306 r = unit_setup_exec_runtime(UNIT(s));
1310 r = socket_arm_timer(s);
1314 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1322 UNIT(s)->manager->environment,
1326 UNIT(s)->manager->confirm_spawn,
1327 UNIT(s)->manager->cgroup_supported,
1328 UNIT(s)->cgroup_path,
1329 manager_get_runtime_prefix(UNIT(s)->manager),
1340 r = unit_watch_pid(UNIT(s), pid);
1342 /* FIXME: we need to do something here */
1350 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1355 static void socket_enter_dead(Socket *s, SocketResult f) {
1358 if (f != SOCKET_SUCCESS)
1361 exec_runtime_destroy(s->exec_runtime);
1362 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1364 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1366 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1369 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1371 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1375 if (f != SOCKET_SUCCESS)
1378 socket_unwatch_control_pid(s);
1380 s->control_command_id = SOCKET_EXEC_STOP_POST;
1382 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1383 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1386 socket_set_state(s, SOCKET_STOP_POST);
1388 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1393 log_warning_unit(UNIT(s)->id,
1394 "%s failed to run 'stop-post' task: %s",
1395 UNIT(s)->id, strerror(-r));
1396 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1399 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1404 if (f != SOCKET_SUCCESS)
1407 r = unit_kill_context(
1410 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1418 r = socket_arm_timer(s);
1422 socket_set_state(s, state);
1423 } else if (state == SOCKET_STOP_PRE_SIGTERM)
1424 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_SUCCESS);
1425 else if (state == SOCKET_STOP_PRE_SIGKILL)
1426 socket_enter_stop_post(s, SOCKET_SUCCESS);
1427 else if (state == SOCKET_FINAL_SIGTERM)
1428 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
1430 socket_enter_dead(s, SOCKET_SUCCESS);
1435 log_warning_unit(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1437 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1438 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1440 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1443 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1447 if (f != SOCKET_SUCCESS)
1450 socket_unwatch_control_pid(s);
1452 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1454 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1455 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1458 socket_set_state(s, SOCKET_STOP_PRE);
1460 socket_enter_stop_post(s, SOCKET_SUCCESS);
1465 log_warning_unit(UNIT(s)->id, "%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1466 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1469 static void socket_enter_listening(Socket *s) {
1473 r = socket_watch_fds(s);
1475 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1479 socket_set_state(s, SOCKET_LISTENING);
1483 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1486 static void socket_enter_start_post(Socket *s) {
1490 r = socket_open_fds(s);
1492 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1496 socket_unwatch_control_pid(s);
1498 s->control_command_id = SOCKET_EXEC_START_POST;
1500 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1501 r = socket_spawn(s, s->control_command, &s->control_pid);
1503 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1507 socket_set_state(s, SOCKET_START_POST);
1509 socket_enter_listening(s);
1514 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1517 static void socket_enter_start_pre(Socket *s) {
1521 socket_unwatch_control_pid(s);
1523 s->control_command_id = SOCKET_EXEC_START_PRE;
1525 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1526 r = socket_spawn(s, s->control_command, &s->control_pid);
1530 socket_set_state(s, SOCKET_START_PRE);
1532 socket_enter_start_post(s);
1537 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1538 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1541 static void socket_enter_running(Socket *s, int cfd) {
1542 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1547 /* We don't take connections anymore if we are supposed to
1548 * shut down anyway */
1549 if (unit_stop_pending(UNIT(s))) {
1551 log_debug_unit(UNIT(s)->id, "Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1556 /* Flush all sockets by closing and reopening them */
1557 socket_close_fds(s);
1559 r = socket_open_fds(s);
1561 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1562 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1566 r = socket_watch_fds(s);
1568 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1569 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1579 bool pending = false;
1581 /* If there's already a start pending don't bother to
1583 SET_FOREACH(other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1584 if (unit_active_or_pending(other)) {
1590 if (!UNIT_ISSET(s->service)) {
1591 log_error_unit(UNIT(s)->id, "%s: service to activate vanished, refusing activation.", UNIT(s)->id);
1596 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1601 socket_set_state(s, SOCKET_RUNNING);
1603 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1606 if (s->n_connections >= s->max_connections) {
1607 log_warning_unit(UNIT(s)->id, "%s: Too many incoming connections (%u)", UNIT(s)->id, s->n_connections);
1612 r = socket_instantiate_service(s);
1616 r = instance_from_socket(cfd, s->n_accepted, &instance);
1621 /* ENOTCONN is legitimate if TCP RST was received.
1622 * This connection is over, but the socket unit lives on. */
1627 prefix = unit_name_to_prefix(UNIT(s)->id);
1633 name = unit_name_build(prefix, instance, ".service");
1639 r = unit_add_name(UNIT_DEREF(s->service), name);
1643 service = SERVICE(UNIT_DEREF(s->service));
1644 unit_ref_unset(&s->service);
1647 UNIT(service)->no_gc = false;
1649 unit_choose_id(UNIT(service), name);
1651 r = service_set_socket_fd(service, cfd, s);
1656 s->n_connections ++;
1658 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1662 /* Notify clients about changed counters */
1663 unit_add_to_dbus_queue(UNIT(s));
1669 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",
1670 UNIT(s)->id, cfd >= 0 ? "template" : "non-template",
1671 bus_error_message(&error, r));
1673 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1677 static void socket_run_next(Socket *s) {
1681 assert(s->control_command);
1682 assert(s->control_command->command_next);
1684 socket_unwatch_control_pid(s);
1686 s->control_command = s->control_command->command_next;
1688 r = socket_spawn(s, s->control_command, &s->control_pid);
1695 log_warning_unit(UNIT(s)->id, "%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1697 if (s->state == SOCKET_START_POST)
1698 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1699 else if (s->state == SOCKET_STOP_POST)
1700 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1702 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1705 static int socket_start(Unit *u) {
1706 Socket *s = SOCKET(u);
1710 /* We cannot fulfill this request right now, try again later
1712 if (s->state == SOCKET_STOP_PRE ||
1713 s->state == SOCKET_STOP_PRE_SIGKILL ||
1714 s->state == SOCKET_STOP_PRE_SIGTERM ||
1715 s->state == SOCKET_STOP_POST ||
1716 s->state == SOCKET_FINAL_SIGTERM ||
1717 s->state == SOCKET_FINAL_SIGKILL)
1720 if (s->state == SOCKET_START_PRE ||
1721 s->state == SOCKET_START_POST)
1724 /* Cannot run this without the service being around */
1725 if (UNIT_ISSET(s->service)) {
1728 service = SERVICE(UNIT_DEREF(s->service));
1730 if (UNIT(service)->load_state != UNIT_LOADED) {
1731 log_error_unit(u->id, "Socket service %s not loaded, refusing.", UNIT(service)->id);
1735 /* If the service is already active we cannot start the
1737 if (service->state != SERVICE_DEAD &&
1738 service->state != SERVICE_FAILED &&
1739 service->state != SERVICE_AUTO_RESTART) {
1740 log_error_unit(u->id, "Socket service %s already active, refusing.", UNIT(service)->id);
1744 #ifdef HAVE_SYSV_COMPAT
1745 if (service->is_sysv) {
1746 log_error_unit(u->id,
1747 "Using SysV services for socket activation is not supported. Refusing.");
1753 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1755 s->result = SOCKET_SUCCESS;
1756 socket_enter_start_pre(s);
1761 static int socket_stop(Unit *u) {
1762 Socket *s = SOCKET(u);
1767 if (s->state == SOCKET_STOP_PRE ||
1768 s->state == SOCKET_STOP_PRE_SIGTERM ||
1769 s->state == SOCKET_STOP_PRE_SIGKILL ||
1770 s->state == SOCKET_STOP_POST ||
1771 s->state == SOCKET_FINAL_SIGTERM ||
1772 s->state == SOCKET_FINAL_SIGKILL)
1775 /* If there's already something running we go directly into
1777 if (s->state == SOCKET_START_PRE ||
1778 s->state == SOCKET_START_POST) {
1779 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1783 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1785 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1789 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1790 Socket *s = SOCKET(u);
1798 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1799 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1800 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1802 if (s->control_pid > 0)
1803 unit_serialize_item_format(u, f, "control-pid", PID_FMT, s->control_pid);
1805 if (s->control_command_id >= 0)
1806 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1808 LIST_FOREACH(port, p, s->ports) {
1814 copy = fdset_put_dup(fds, p->fd);
1818 if (p->type == SOCKET_SOCKET) {
1819 _cleanup_free_ char *t = NULL;
1821 r = socket_address_print(&p->address, &t);
1825 if (socket_address_family(&p->address) == AF_NETLINK)
1826 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1828 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1830 } else if (p->type == SOCKET_SPECIAL)
1831 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1832 else if (p->type == SOCKET_MQUEUE)
1833 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1835 assert(p->type == SOCKET_FIFO);
1836 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1843 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1844 Socket *s = SOCKET(u);
1850 if (streq(key, "state")) {
1853 state = socket_state_from_string(value);
1855 log_debug_unit(u->id, "Failed to parse state value %s", value);
1857 s->deserialized_state = state;
1858 } else if (streq(key, "result")) {
1861 f = socket_result_from_string(value);
1863 log_debug_unit(u->id, "Failed to parse result value %s", value);
1864 else if (f != SOCKET_SUCCESS)
1867 } else if (streq(key, "n-accepted")) {
1870 if (safe_atou(value, &k) < 0)
1871 log_debug_unit(u->id, "Failed to parse n-accepted value %s", value);
1874 } else if (streq(key, "control-pid")) {
1877 if (parse_pid(value, &pid) < 0)
1878 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1880 s->control_pid = pid;
1881 } else if (streq(key, "control-command")) {
1882 SocketExecCommand id;
1884 id = socket_exec_command_from_string(value);
1886 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1888 s->control_command_id = id;
1889 s->control_command = s->exec_command[id];
1891 } else if (streq(key, "fifo")) {
1895 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1896 log_debug_unit(u->id, "Failed to parse fifo value %s", value);
1899 LIST_FOREACH(port, p, s->ports)
1900 if (p->type == SOCKET_FIFO &&
1901 streq_ptr(p->path, value+skip))
1906 p->fd = fdset_remove(fds, fd);
1910 } else if (streq(key, "special")) {
1914 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1915 log_debug_unit(u->id, "Failed to parse special value %s", value);
1918 LIST_FOREACH(port, p, s->ports)
1919 if (p->type == SOCKET_SPECIAL &&
1920 streq_ptr(p->path, value+skip))
1925 p->fd = fdset_remove(fds, fd);
1929 } else if (streq(key, "mqueue")) {
1933 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1934 log_debug_unit(u->id, "Failed to parse mqueue value %s", value);
1937 LIST_FOREACH(port, p, s->ports)
1938 if (p->type == SOCKET_MQUEUE &&
1939 streq_ptr(p->path, value+skip))
1944 p->fd = fdset_remove(fds, fd);
1948 } else if (streq(key, "socket")) {
1949 int fd, type, skip = 0;
1952 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1953 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1956 LIST_FOREACH(port, p, s->ports)
1957 if (socket_address_is(&p->address, value+skip, type))
1962 p->fd = fdset_remove(fds, fd);
1966 } else if (streq(key, "netlink")) {
1970 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1971 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1974 LIST_FOREACH(port, p, s->ports)
1975 if (socket_address_is_netlink(&p->address, value+skip))
1980 p->fd = fdset_remove(fds, fd);
1984 log_debug_unit(UNIT(s)->id, "Unknown serialization key '%s'", key);
1989 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1990 Socket *s = SOCKET(u);
1995 LIST_FOREACH(port, p, s->ports) {
1999 if (p->type != SOCKET_SOCKET)
2005 FDSET_FOREACH(fd, fds, i) {
2006 if (socket_address_matches_fd(&p->address, fd)) {
2007 p->fd = fdset_remove(fds, fd);
2008 s->deserialized_state = SOCKET_LISTENING;
2017 _pure_ static UnitActiveState socket_active_state(Unit *u) {
2020 return state_translation_table[SOCKET(u)->state];
2023 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
2026 return socket_state_to_string(SOCKET(u)->state);
2029 const char* socket_port_type_to_string(SocketPort *p) {
2037 switch (p->address.type) {
2045 case SOCK_SEQPACKET:
2046 return "SequentialPacket";
2049 if (socket_address_family(&p->address) == AF_NETLINK)
2056 case SOCKET_SPECIAL:
2060 return "MessageQueue";
2070 _pure_ static bool socket_check_gc(Unit *u) {
2071 Socket *s = SOCKET(u);
2075 return s->n_connections > 0;
2078 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2079 SocketPort *p = userdata;
2085 if (p->socket->state != SOCKET_LISTENING)
2088 log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
2090 if (revents != EPOLLIN) {
2092 if (revents & EPOLLHUP)
2093 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.",
2094 UNIT(p->socket)->id);
2096 log_error_unit(UNIT(p->socket)->id, "%s: Got unexpected poll event (0x%x) on socket.",
2097 UNIT(p->socket)->id, revents);
2102 if (p->socket->accept &&
2103 p->type == SOCKET_SOCKET &&
2104 socket_address_can_accept(&p->address)) {
2108 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2114 log_error_unit(UNIT(p->socket)->id,
2115 "Failed to accept socket: %m");
2122 socket_apply_socket_options(p->socket, cfd);
2125 socket_enter_running(p->socket, cfd);
2129 socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2133 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2134 Socket *s = SOCKET(u);
2140 if (pid != s->control_pid)
2145 if (is_clean_exit(code, status, NULL))
2147 else if (code == CLD_EXITED)
2148 f = SOCKET_FAILURE_EXIT_CODE;
2149 else if (code == CLD_KILLED)
2150 f = SOCKET_FAILURE_SIGNAL;
2151 else if (code == CLD_DUMPED)
2152 f = SOCKET_FAILURE_CORE_DUMP;
2154 assert_not_reached("Unknown code");
2156 if (s->control_command) {
2157 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2159 if (s->control_command->ignore)
2163 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2165 "%s control process exited, code=%s status=%i",
2166 u->id, sigchld_code_to_string(code), status);
2168 if (f != SOCKET_SUCCESS)
2171 if (s->control_command &&
2172 s->control_command->command_next &&
2173 f == SOCKET_SUCCESS) {
2175 log_debug_unit(u->id,
2176 "%s running next command for state %s",
2177 u->id, socket_state_to_string(s->state));
2180 s->control_command = NULL;
2181 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2183 /* No further commands for this step, so let's figure
2184 * out what to do next */
2186 log_debug_unit(u->id,
2187 "%s got final SIGCHLD for state %s",
2188 u->id, socket_state_to_string(s->state));
2192 case SOCKET_START_PRE:
2193 if (f == SOCKET_SUCCESS)
2194 socket_enter_start_post(s);
2196 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2199 case SOCKET_START_POST:
2200 if (f == SOCKET_SUCCESS)
2201 socket_enter_listening(s);
2203 socket_enter_stop_pre(s, f);
2206 case SOCKET_STOP_PRE:
2207 case SOCKET_STOP_PRE_SIGTERM:
2208 case SOCKET_STOP_PRE_SIGKILL:
2209 socket_enter_stop_post(s, f);
2212 case SOCKET_STOP_POST:
2213 case SOCKET_FINAL_SIGTERM:
2214 case SOCKET_FINAL_SIGKILL:
2215 socket_enter_dead(s, f);
2219 assert_not_reached("Uh, control process died at wrong time.");
2223 /* Notify clients about changed exit status */
2224 unit_add_to_dbus_queue(u);
2227 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2228 Socket *s = SOCKET(userdata);
2231 assert(s->timer_event_source == source);
2235 case SOCKET_START_PRE:
2236 log_warning_unit(UNIT(s)->id,
2237 "%s starting timed out. Terminating.", UNIT(s)->id);
2238 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2241 case SOCKET_START_POST:
2242 log_warning_unit(UNIT(s)->id,
2243 "%s starting timed out. Stopping.", UNIT(s)->id);
2244 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2247 case SOCKET_STOP_PRE:
2248 log_warning_unit(UNIT(s)->id,
2249 "%s stopping timed out. Terminating.", UNIT(s)->id);
2250 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2253 case SOCKET_STOP_PRE_SIGTERM:
2254 if (s->kill_context.send_sigkill) {
2255 log_warning_unit(UNIT(s)->id,
2256 "%s stopping timed out. Killing.", UNIT(s)->id);
2257 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2259 log_warning_unit(UNIT(s)->id,
2260 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2262 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2266 case SOCKET_STOP_PRE_SIGKILL:
2267 log_warning_unit(UNIT(s)->id,
2268 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2269 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2272 case SOCKET_STOP_POST:
2273 log_warning_unit(UNIT(s)->id,
2274 "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2275 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2278 case SOCKET_FINAL_SIGTERM:
2279 if (s->kill_context.send_sigkill) {
2280 log_warning_unit(UNIT(s)->id,
2281 "%s stopping timed out (2). Killing.", UNIT(s)->id);
2282 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2284 log_warning_unit(UNIT(s)->id,
2285 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2287 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2291 case SOCKET_FINAL_SIGKILL:
2292 log_warning_unit(UNIT(s)->id,
2293 "%s still around after SIGKILL (2). Entering failed mode.",
2295 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2299 assert_not_reached("Timeout at wrong time.");
2305 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2314 /* Called from the service code for requesting our fds */
2317 LIST_FOREACH(port, p, s->ports)
2327 if (!(rfds = new(int, rn_fds)))
2331 LIST_FOREACH(port, p, s->ports)
2335 assert(k == rn_fds);
2343 static void socket_reset_failed(Unit *u) {
2344 Socket *s = SOCKET(u);
2348 if (s->state == SOCKET_FAILED)
2349 socket_set_state(s, SOCKET_DEAD);
2351 s->result = SOCKET_SUCCESS;
2354 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2357 /* The service is dead. Dang!
2359 * This is strictly for one-instance-for-all-connections
2362 if (s->state == SOCKET_RUNNING) {
2363 log_debug_unit(UNIT(s)->id, "%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2364 if (failed_permanent)
2365 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2367 socket_enter_listening(s);
2371 void socket_connection_unref(Socket *s) {
2374 /* The service is dead. Yay!
2376 * This is strictly for one-instance-per-connection
2379 assert(s->n_connections > 0);
2382 log_debug_unit(UNIT(s)->id, "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2385 static void socket_trigger_notify(Unit *u, Unit *other) {
2386 Socket *s = SOCKET(u);
2392 /* Don't propagate state changes from the service if we are
2393 already down or accepting connections */
2394 if ((s->state != SOCKET_RUNNING &&
2395 s->state != SOCKET_LISTENING) ||
2399 if (other->load_state != UNIT_LOADED ||
2400 other->type != UNIT_SERVICE)
2403 se = SERVICE(other);
2405 if (se->state == SERVICE_FAILED)
2406 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2408 if (se->state == SERVICE_DEAD ||
2409 se->state == SERVICE_STOP ||
2410 se->state == SERVICE_STOP_SIGTERM ||
2411 se->state == SERVICE_STOP_SIGKILL ||
2412 se->state == SERVICE_STOP_POST ||
2413 se->state == SERVICE_FINAL_SIGTERM ||
2414 se->state == SERVICE_FINAL_SIGKILL ||
2415 se->state == SERVICE_AUTO_RESTART)
2416 socket_notify_service_dead(s, false);
2418 if (se->state == SERVICE_RUNNING)
2419 socket_set_state(s, SOCKET_RUNNING);
2422 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2423 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2426 static int socket_get_timeout(Unit *u, uint64_t *timeout) {
2427 Socket *s = SOCKET(u);
2430 if (!s->timer_event_source)
2433 r = sd_event_source_get_time(s->timer_event_source, timeout);
2440 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2441 [SOCKET_DEAD] = "dead",
2442 [SOCKET_START_PRE] = "start-pre",
2443 [SOCKET_START_POST] = "start-post",
2444 [SOCKET_LISTENING] = "listening",
2445 [SOCKET_RUNNING] = "running",
2446 [SOCKET_STOP_PRE] = "stop-pre",
2447 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2448 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2449 [SOCKET_STOP_POST] = "stop-post",
2450 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2451 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2452 [SOCKET_FAILED] = "failed"
2455 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2457 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2458 [SOCKET_EXEC_START_PRE] = "StartPre",
2459 [SOCKET_EXEC_START_POST] = "StartPost",
2460 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2461 [SOCKET_EXEC_STOP_POST] = "StopPost"
2464 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2466 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2467 [SOCKET_SUCCESS] = "success",
2468 [SOCKET_FAILURE_RESOURCES] = "resources",
2469 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2470 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2471 [SOCKET_FAILURE_SIGNAL] = "signal",
2472 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2473 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2476 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2478 const UnitVTable socket_vtable = {
2479 .object_size = sizeof(Socket),
2480 .exec_context_offset = offsetof(Socket, exec_context),
2481 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2482 .kill_context_offset = offsetof(Socket, kill_context),
2483 .exec_runtime_offset = offsetof(Socket, exec_runtime),
2489 .private_section = "Socket",
2491 .init = socket_init,
2492 .done = socket_done,
2493 .load = socket_load,
2495 .coldplug = socket_coldplug,
2497 .dump = socket_dump,
2499 .start = socket_start,
2500 .stop = socket_stop,
2502 .kill = socket_kill,
2504 .get_timeout = socket_get_timeout,
2506 .serialize = socket_serialize,
2507 .deserialize_item = socket_deserialize_item,
2508 .distribute_fds = socket_distribute_fds,
2510 .active_state = socket_active_state,
2511 .sub_state_to_string = socket_sub_state_to_string,
2513 .check_gc = socket_check_gc,
2515 .sigchld_event = socket_sigchld_event,
2517 .trigger_notify = socket_trigger_notify,
2519 .reset_failed = socket_reset_failed,
2521 .bus_interface = "org.freedesktop.systemd1.Socket",
2522 .bus_vtable = bus_socket_vtable,
2523 .bus_set_property = bus_socket_set_property,
2524 .bus_commit_properties = bus_socket_commit_properties,
2526 .status_message_formats = {
2527 /*.starting_stopping = {
2528 [0] = "Starting socket %s...",
2529 [1] = "Stopping socket %s...",
2531 .finished_start_job = {
2532 [JOB_DONE] = "Listening on %s.",
2533 [JOB_FAILED] = "Failed to listen on %s.",
2534 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2535 [JOB_TIMEOUT] = "Timed out starting %s.",
2537 .finished_stop_job = {
2538 [JOB_DONE] = "Closed %s.",
2539 [JOB_FAILED] = "Failed stopping %s.",
2540 [JOB_TIMEOUT] = "Timed out stopping %s.",