1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include <sys/types.h>
27 #include <sys/epoll.h>
29 #include <arpa/inet.h>
30 #include <netinet/tcp.h>
33 #include <attr/xattr.h>
38 #include "load-dropin.h"
39 #include "load-fragment.h"
42 #include "path-util.h"
43 #include "unit-name.h"
44 #include "unit-printf.h"
48 #include "exit-status.h"
50 #include "smack-util.h"
52 #include "bus-error.h"
53 #include "dbus-socket.h"
57 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
58 [SOCKET_DEAD] = UNIT_INACTIVE,
59 [SOCKET_START_PRE] = UNIT_ACTIVATING,
60 [SOCKET_START_POST] = UNIT_ACTIVATING,
61 [SOCKET_LISTENING] = UNIT_ACTIVE,
62 [SOCKET_RUNNING] = UNIT_ACTIVE,
63 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
64 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
65 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
66 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
67 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
68 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
69 [SOCKET_FAILED] = UNIT_FAILED
72 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
73 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
75 static void socket_init(Unit *u) {
76 Socket *s = SOCKET(u);
79 assert(u->load_state == UNIT_STUB);
81 s->backlog = SOMAXCONN;
82 s->timeout_usec = u->manager->default_timeout_start_usec;
83 s->directory_mode = 0755;
84 s->socket_mode = 0666;
86 s->max_connections = 64;
93 exec_context_init(&s->exec_context);
94 s->exec_context.std_output = u->manager->default_std_output;
95 s->exec_context.std_error = u->manager->default_std_error;
96 kill_context_init(&s->kill_context);
97 cgroup_context_init(&s->cgroup_context);
99 unit_cgroup_context_init_defaults(u, &s->cgroup_context);
101 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
104 static void socket_unwatch_control_pid(Socket *s) {
107 if (s->control_pid <= 0)
110 unit_unwatch_pid(UNIT(s), s->control_pid);
114 void socket_free_ports(Socket *s) {
119 while ((p = s->ports)) {
120 LIST_REMOVE(port, s->ports, p);
122 sd_event_source_unref(p->event_source);
125 close_nointr_nofail(p->fd);
132 static void socket_done(Unit *u) {
133 Socket *s = SOCKET(u);
137 socket_free_ports(s);
139 cgroup_context_done(&s->cgroup_context);
140 exec_context_done(&s->exec_context);
141 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
142 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
143 s->control_command = NULL;
145 socket_unwatch_control_pid(s);
147 unit_ref_unset(&s->service);
149 free(s->tcp_congestion);
150 s->tcp_congestion = NULL;
152 free(s->bind_to_device);
153 s->bind_to_device = NULL;
156 free(s->smack_ip_in);
157 free(s->smack_ip_out);
159 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
162 static int socket_arm_timer(Socket *s) {
167 if (s->timeout_usec <= 0) {
168 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
172 if (s->timer_event_source) {
173 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec);
177 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
180 return sd_event_add_monotonic(UNIT(s)->manager->event, &s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec, 0, socket_dispatch_timer, s);
183 static int socket_instantiate_service(Socket *s) {
184 _cleanup_free_ char *prefix = NULL;
185 _cleanup_free_ char *name = NULL;
191 /* This fills in s->service if it isn't filled in yet. For
192 * Accept=yes sockets we create the next connection service
193 * here. For Accept=no this is mostly a NOP since the service
194 * is figured out at load time anyway. */
196 if (UNIT_DEREF(s->service))
201 prefix = unit_name_to_prefix(UNIT(s)->id);
205 if (asprintf(&name, "%s@%u.service", prefix, s->n_accepted) < 0)
208 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_patch_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) {
598 union sockaddr_union local, remote;
604 if (getsockname(fd, &local.sa, &l) < 0)
608 if (getpeername(fd, &remote.sa, &l) < 0)
611 switch (local.sa.sa_family) {
615 a = ntohl(local.in.sin_addr.s_addr),
616 b = ntohl(remote.in.sin_addr.s_addr);
619 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
621 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
622 ntohs(local.in.sin_port),
623 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
624 ntohs(remote.in.sin_port)) < 0)
631 static const unsigned char ipv4_prefix[] = {
632 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
635 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
636 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
638 *a = local.in6.sin6_addr.s6_addr+12,
639 *b = remote.in6.sin6_addr.s6_addr+12;
642 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
644 a[0], a[1], a[2], a[3],
645 ntohs(local.in6.sin6_port),
646 b[0], b[1], b[2], b[3],
647 ntohs(remote.in6.sin6_port)) < 0)
650 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
655 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
656 ntohs(local.in6.sin6_port),
657 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
658 ntohs(remote.in6.sin6_port)) < 0)
669 k = getpeercred(fd, &ucred);
676 (unsigned long) ucred.pid,
677 (unsigned long) ucred.uid) < 0)
684 assert_not_reached("Unhandled socket type.");
691 static void socket_close_fds(Socket *s) {
696 LIST_FOREACH(port, p, s->ports) {
698 p->event_source = sd_event_source_unref(p->event_source);
703 close_nointr_nofail(p->fd);
705 /* One little note: we should never delete any sockets
706 * in the file system here! After all some other
707 * process we spawned might still have a reference of
708 * this fd and wants to continue to use it. Therefore
709 * we delete sockets in the file system before we
710 * create a new one, not after we stopped using
717 static void socket_apply_socket_options(Socket *s, int fd) {
722 int b = s->keep_alive;
723 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
724 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
729 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
730 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
735 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
736 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
741 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
742 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
745 if (s->priority >= 0)
746 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
747 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
749 if (s->receive_buffer > 0) {
750 int value = (int) s->receive_buffer;
752 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
754 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
755 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
756 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
759 if (s->send_buffer > 0) {
760 int value = (int) s->send_buffer;
761 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
762 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
763 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
767 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
768 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
771 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
772 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
774 if (s->ip_ttl >= 0) {
777 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
779 if (socket_ipv6_is_supported())
780 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
783 errno = EAFNOSUPPORT;
787 log_warning_unit(UNIT(s)->id,
788 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
791 if (s->tcp_congestion)
792 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
793 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
796 int b = s->reuse_port;
797 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)) < 0)
798 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
802 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
803 log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
806 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
807 log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
810 static void socket_apply_fifo_options(Socket *s, int fd) {
814 if (s->pipe_size > 0)
815 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
816 log_warning_unit(UNIT(s)->id,
820 if (smack_label_fd(fd, s->smack) < 0)
821 log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
824 static int fifo_address_create(
826 mode_t directory_mode,
837 mkdir_parents_label(path, directory_mode);
839 r = label_context_set(path, S_IFIFO);
843 /* Enforce the right access mode for the fifo */
844 old_mask = umask(~ socket_mode);
846 /* Include the original umask in our mask */
847 umask(~socket_mode | old_mask);
849 r = mkfifo(path, socket_mode);
852 if (r < 0 && errno != EEXIST) {
857 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
862 label_context_clear();
864 if (fstat(fd, &st) < 0) {
869 if (!S_ISFIFO(st.st_mode) ||
870 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
871 st.st_uid != getuid() ||
872 st.st_gid != getgid()) {
882 label_context_clear();
885 close_nointr_nofail(fd);
890 static int special_address_create(
900 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
905 if (fstat(fd, &st) < 0) {
910 /* Check whether this is a /proc, /sys or /dev file or char device */
911 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
921 close_nointr_nofail(fd);
926 static int mq_address_create(
936 struct mq_attr _attr, *attr = NULL;
941 if (maxmsg > 0 && msgsize > 0) {
943 _attr.mq_flags = O_NONBLOCK;
944 _attr.mq_maxmsg = maxmsg;
945 _attr.mq_msgsize = msgsize;
949 /* Enforce the right access mode for the mq */
950 old_mask = umask(~ mq_mode);
952 /* Include the original umask in our mask */
953 umask(~mq_mode | old_mask);
955 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
963 if (fstat(fd, &st) < 0) {
968 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
969 st.st_uid != getuid() ||
970 st.st_gid != getgid()) {
981 close_nointr_nofail(fd);
986 static int socket_open_fds(Socket *s) {
990 bool know_label = false;
994 LIST_FOREACH(port, p, s->ports) {
999 if (p->type == SOCKET_SOCKET) {
1003 if ((r = socket_instantiate_service(s)) < 0)
1006 if (UNIT_ISSET(s->service) &&
1007 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1008 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1019 r = socket_address_listen(
1021 SOCK_CLOEXEC|SOCK_NONBLOCK,
1034 socket_apply_socket_options(s, p->fd);
1036 } else if (p->type == SOCKET_SPECIAL) {
1038 r = special_address_create(
1044 } else if (p->type == SOCKET_FIFO) {
1046 r = fifo_address_create(
1054 socket_apply_fifo_options(s, p->fd);
1055 } else if (p->type == SOCKET_MQUEUE) {
1057 r = mq_address_create(
1066 assert_not_reached("Unknown port type");
1073 socket_close_fds(s);
1078 static void socket_unwatch_fds(Socket *s) {
1084 LIST_FOREACH(port, p, s->ports) {
1088 if (p->event_source) {
1089 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_OFF);
1091 log_debug_unit(UNIT(s)->id, "Failed to disable event source.");
1096 static int socket_watch_fds(Socket *s) {
1102 LIST_FOREACH(port, p, s->ports) {
1106 if (p->event_source)
1107 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1109 r = sd_event_add_io(UNIT(s)->manager->event, &p->event_source, p->fd, EPOLLIN, socket_dispatch_io, p);
1112 log_warning_unit(UNIT(s)->id, "Failed to watch listening fds: %s", strerror(-r));
1120 socket_unwatch_fds(s);
1124 static void socket_set_state(Socket *s, SocketState state) {
1125 SocketState old_state;
1128 old_state = s->state;
1131 if (state != SOCKET_START_PRE &&
1132 state != SOCKET_START_POST &&
1133 state != SOCKET_STOP_PRE &&
1134 state != SOCKET_STOP_PRE_SIGTERM &&
1135 state != SOCKET_STOP_PRE_SIGKILL &&
1136 state != SOCKET_STOP_POST &&
1137 state != SOCKET_FINAL_SIGTERM &&
1138 state != SOCKET_FINAL_SIGKILL) {
1140 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1141 socket_unwatch_control_pid(s);
1142 s->control_command = NULL;
1143 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1146 if (state != SOCKET_LISTENING)
1147 socket_unwatch_fds(s);
1149 if (state != SOCKET_START_POST &&
1150 state != SOCKET_LISTENING &&
1151 state != SOCKET_RUNNING &&
1152 state != SOCKET_STOP_PRE &&
1153 state != SOCKET_STOP_PRE_SIGTERM &&
1154 state != SOCKET_STOP_PRE_SIGKILL)
1155 socket_close_fds(s);
1157 if (state != old_state)
1158 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s",
1159 UNIT(s)->id, socket_state_to_string(old_state), socket_state_to_string(state));
1161 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1164 static int socket_coldplug(Unit *u) {
1165 Socket *s = SOCKET(u);
1169 assert(s->state == SOCKET_DEAD);
1171 if (s->deserialized_state == s->state)
1174 if (s->deserialized_state == SOCKET_START_PRE ||
1175 s->deserialized_state == SOCKET_START_POST ||
1176 s->deserialized_state == SOCKET_STOP_PRE ||
1177 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1178 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1179 s->deserialized_state == SOCKET_STOP_POST ||
1180 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1181 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1183 if (s->control_pid <= 0)
1186 r = unit_watch_pid(UNIT(s), s->control_pid);
1190 r = socket_arm_timer(s);
1195 if (s->deserialized_state == SOCKET_START_POST ||
1196 s->deserialized_state == SOCKET_LISTENING ||
1197 s->deserialized_state == SOCKET_RUNNING ||
1198 s->deserialized_state == SOCKET_STOP_PRE ||
1199 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1200 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL) {
1201 r = socket_open_fds(s);
1206 if (s->deserialized_state == SOCKET_LISTENING) {
1207 r = socket_watch_fds(s);
1212 socket_set_state(s, s->deserialized_state);
1216 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1225 unit_realize_cgroup(UNIT(s));
1227 r = unit_setup_exec_runtime(UNIT(s));
1231 r = socket_arm_timer(s);
1235 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1243 UNIT(s)->manager->environment,
1247 UNIT(s)->manager->confirm_spawn,
1248 UNIT(s)->manager->cgroup_supported,
1249 UNIT(s)->cgroup_path,
1250 manager_get_runtime_prefix(UNIT(s)->manager),
1261 r = unit_watch_pid(UNIT(s), pid);
1263 /* FIXME: we need to do something here */
1271 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1276 static void socket_enter_dead(Socket *s, SocketResult f) {
1279 if (f != SOCKET_SUCCESS)
1282 exec_runtime_destroy(s->exec_runtime);
1283 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1285 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1287 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1290 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1292 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1296 if (f != SOCKET_SUCCESS)
1299 socket_unwatch_control_pid(s);
1301 s->control_command_id = SOCKET_EXEC_STOP_POST;
1303 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1304 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1307 socket_set_state(s, SOCKET_STOP_POST);
1309 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1314 log_warning_unit(UNIT(s)->id,
1315 "%s failed to run 'stop-post' task: %s",
1316 UNIT(s)->id, strerror(-r));
1317 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1320 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1325 if (f != SOCKET_SUCCESS)
1328 r = unit_kill_context(
1331 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1339 r = socket_arm_timer(s);
1343 socket_set_state(s, state);
1344 } else if (state == SOCKET_STOP_PRE_SIGTERM)
1345 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_SUCCESS);
1346 else if (state == SOCKET_STOP_PRE_SIGKILL)
1347 socket_enter_stop_post(s, SOCKET_SUCCESS);
1348 else if (state == SOCKET_FINAL_SIGTERM)
1349 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
1351 socket_enter_dead(s, SOCKET_SUCCESS);
1356 log_warning_unit(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1358 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1359 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1361 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1364 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1368 if (f != SOCKET_SUCCESS)
1371 socket_unwatch_control_pid(s);
1373 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1375 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1376 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1379 socket_set_state(s, SOCKET_STOP_PRE);
1381 socket_enter_stop_post(s, SOCKET_SUCCESS);
1386 log_warning_unit(UNIT(s)->id, "%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1387 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1390 static void socket_enter_listening(Socket *s) {
1394 r = socket_watch_fds(s);
1396 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1400 socket_set_state(s, SOCKET_LISTENING);
1404 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1407 static void socket_enter_start_post(Socket *s) {
1411 r = socket_open_fds(s);
1413 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1417 socket_unwatch_control_pid(s);
1419 s->control_command_id = SOCKET_EXEC_START_POST;
1421 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1422 r = socket_spawn(s, s->control_command, &s->control_pid);
1424 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1428 socket_set_state(s, SOCKET_START_POST);
1430 socket_enter_listening(s);
1435 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1438 static void socket_enter_start_pre(Socket *s) {
1442 socket_unwatch_control_pid(s);
1444 s->control_command_id = SOCKET_EXEC_START_PRE;
1446 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1447 r = socket_spawn(s, s->control_command, &s->control_pid);
1451 socket_set_state(s, SOCKET_START_PRE);
1453 socket_enter_start_post(s);
1458 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1459 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1462 static void socket_enter_running(Socket *s, int cfd) {
1463 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1468 /* We don't take connections anymore if we are supposed to
1469 * shut down anyway */
1470 if (unit_stop_pending(UNIT(s))) {
1472 log_debug_unit(UNIT(s)->id, "Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1475 close_nointr_nofail(cfd);
1477 /* Flush all sockets by closing and reopening them */
1478 socket_close_fds(s);
1480 r = socket_open_fds(s);
1482 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1483 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1487 r = socket_watch_fds(s);
1489 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1490 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1500 bool pending = false;
1502 /* If there's already a start pending don't bother to
1504 SET_FOREACH(other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1505 if (unit_active_or_pending(other)) {
1511 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1516 socket_set_state(s, SOCKET_RUNNING);
1518 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1521 if (s->n_connections >= s->max_connections) {
1522 log_warning_unit(UNIT(s)->id, "%s: Too many incoming connections (%u)", UNIT(s)->id, s->n_connections);
1523 close_nointr_nofail(cfd);
1527 r = socket_instantiate_service(s);
1531 r = instance_from_socket(cfd, s->n_accepted, &instance);
1536 /* ENOTCONN is legitimate if TCP RST was received.
1537 * This connection is over, but the socket unit lives on. */
1538 close_nointr_nofail(cfd);
1542 prefix = unit_name_to_prefix(UNIT(s)->id);
1548 name = unit_name_build(prefix, instance, ".service");
1554 r = unit_add_name(UNIT_DEREF(s->service), name);
1558 service = SERVICE(UNIT_DEREF(s->service));
1559 unit_ref_unset(&s->service);
1562 UNIT(service)->no_gc = false;
1564 unit_choose_id(UNIT(service), name);
1566 r = service_set_socket_fd(service, cfd, s);
1571 s->n_connections ++;
1573 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1577 /* Notify clients about changed counters */
1578 unit_add_to_dbus_queue(UNIT(s));
1584 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",
1585 UNIT(s)->id, cfd >= 0 ? "template" : "non-template",
1586 bus_error_message(&error, r));
1588 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1591 close_nointr_nofail(cfd);
1594 static void socket_run_next(Socket *s) {
1598 assert(s->control_command);
1599 assert(s->control_command->command_next);
1601 socket_unwatch_control_pid(s);
1603 s->control_command = s->control_command->command_next;
1605 r = socket_spawn(s, s->control_command, &s->control_pid);
1612 log_warning_unit(UNIT(s)->id, "%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1614 if (s->state == SOCKET_START_POST)
1615 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1616 else if (s->state == SOCKET_STOP_POST)
1617 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1619 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1622 static int socket_start(Unit *u) {
1623 Socket *s = SOCKET(u);
1627 /* We cannot fulfill this request right now, try again later
1629 if (s->state == SOCKET_STOP_PRE ||
1630 s->state == SOCKET_STOP_PRE_SIGKILL ||
1631 s->state == SOCKET_STOP_PRE_SIGTERM ||
1632 s->state == SOCKET_STOP_POST ||
1633 s->state == SOCKET_FINAL_SIGTERM ||
1634 s->state == SOCKET_FINAL_SIGKILL)
1637 if (s->state == SOCKET_START_PRE ||
1638 s->state == SOCKET_START_POST)
1641 /* Cannot run this without the service being around */
1642 if (UNIT_ISSET(s->service)) {
1645 service = SERVICE(UNIT_DEREF(s->service));
1647 if (UNIT(service)->load_state != UNIT_LOADED) {
1648 log_error_unit(u->id, "Socket service %s not loaded, refusing.", UNIT(service)->id);
1652 /* If the service is already active we cannot start the
1654 if (service->state != SERVICE_DEAD &&
1655 service->state != SERVICE_FAILED &&
1656 service->state != SERVICE_AUTO_RESTART) {
1657 log_error_unit(u->id, "Socket service %s already active, refusing.", UNIT(service)->id);
1661 #ifdef HAVE_SYSV_COMPAT
1662 if (service->is_sysv) {
1663 log_error_unit(u->id,
1664 "Using SysV services for socket activation is not supported. Refusing.");
1670 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1672 s->result = SOCKET_SUCCESS;
1673 socket_enter_start_pre(s);
1678 static int socket_stop(Unit *u) {
1679 Socket *s = SOCKET(u);
1684 if (s->state == SOCKET_STOP_PRE ||
1685 s->state == SOCKET_STOP_PRE_SIGTERM ||
1686 s->state == SOCKET_STOP_PRE_SIGKILL ||
1687 s->state == SOCKET_STOP_POST ||
1688 s->state == SOCKET_FINAL_SIGTERM ||
1689 s->state == SOCKET_FINAL_SIGKILL)
1692 /* If there's already something running we go directly into
1694 if (s->state == SOCKET_START_PRE ||
1695 s->state == SOCKET_START_POST) {
1696 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1700 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1702 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1706 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1707 Socket *s = SOCKET(u);
1715 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1716 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1717 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1719 if (s->control_pid > 0)
1720 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1722 if (s->control_command_id >= 0)
1723 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1725 LIST_FOREACH(port, p, s->ports) {
1731 copy = fdset_put_dup(fds, p->fd);
1735 if (p->type == SOCKET_SOCKET) {
1736 _cleanup_free_ char *t = NULL;
1738 r = socket_address_print(&p->address, &t);
1742 if (socket_address_family(&p->address) == AF_NETLINK)
1743 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1745 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1747 } else if (p->type == SOCKET_SPECIAL)
1748 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1749 else if (p->type == SOCKET_MQUEUE)
1750 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1752 assert(p->type == SOCKET_FIFO);
1753 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1760 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1761 Socket *s = SOCKET(u);
1767 if (streq(key, "state")) {
1770 state = socket_state_from_string(value);
1772 log_debug_unit(u->id, "Failed to parse state value %s", value);
1774 s->deserialized_state = state;
1775 } else if (streq(key, "result")) {
1778 f = socket_result_from_string(value);
1780 log_debug_unit(u->id, "Failed to parse result value %s", value);
1781 else if (f != SOCKET_SUCCESS)
1784 } else if (streq(key, "n-accepted")) {
1787 if (safe_atou(value, &k) < 0)
1788 log_debug_unit(u->id, "Failed to parse n-accepted value %s", value);
1791 } else if (streq(key, "control-pid")) {
1794 if (parse_pid(value, &pid) < 0)
1795 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1797 s->control_pid = pid;
1798 } else if (streq(key, "control-command")) {
1799 SocketExecCommand id;
1801 id = socket_exec_command_from_string(value);
1803 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1805 s->control_command_id = id;
1806 s->control_command = s->exec_command[id];
1808 } else if (streq(key, "fifo")) {
1812 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1813 log_debug_unit(u->id, "Failed to parse fifo value %s", value);
1816 LIST_FOREACH(port, p, s->ports)
1817 if (p->type == SOCKET_FIFO &&
1818 streq_ptr(p->path, value+skip))
1823 close_nointr_nofail(p->fd);
1824 p->fd = fdset_remove(fds, fd);
1828 } else if (streq(key, "special")) {
1832 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1833 log_debug_unit(u->id, "Failed to parse special value %s", value);
1836 LIST_FOREACH(port, p, s->ports)
1837 if (p->type == SOCKET_SPECIAL &&
1838 streq_ptr(p->path, value+skip))
1843 close_nointr_nofail(p->fd);
1844 p->fd = fdset_remove(fds, fd);
1848 } else if (streq(key, "mqueue")) {
1852 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1853 log_debug_unit(u->id, "Failed to parse mqueue value %s", value);
1856 LIST_FOREACH(port, p, s->ports)
1857 if (p->type == SOCKET_MQUEUE &&
1858 streq_ptr(p->path, value+skip))
1863 close_nointr_nofail(p->fd);
1864 p->fd = fdset_remove(fds, fd);
1868 } else if (streq(key, "socket")) {
1869 int fd, type, skip = 0;
1872 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1873 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1876 LIST_FOREACH(port, p, s->ports)
1877 if (socket_address_is(&p->address, value+skip, type))
1882 close_nointr_nofail(p->fd);
1883 p->fd = fdset_remove(fds, fd);
1887 } else if (streq(key, "netlink")) {
1891 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1892 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1895 LIST_FOREACH(port, p, s->ports)
1896 if (socket_address_is_netlink(&p->address, value+skip))
1901 close_nointr_nofail(p->fd);
1902 p->fd = fdset_remove(fds, fd);
1906 log_debug_unit(UNIT(s)->id, "Unknown serialization key '%s'", key);
1911 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1912 Socket *s = SOCKET(u);
1917 LIST_FOREACH(port, p, s->ports) {
1921 if (p->type != SOCKET_SOCKET)
1927 FDSET_FOREACH(fd, fds, i) {
1928 if (socket_address_matches_fd(&p->address, fd)) {
1929 p->fd = fdset_remove(fds, fd);
1930 s->deserialized_state = SOCKET_LISTENING;
1939 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1942 return state_translation_table[SOCKET(u)->state];
1945 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1948 return socket_state_to_string(SOCKET(u)->state);
1951 const char* socket_port_type_to_string(SocketPort *p) {
1959 switch (p->address.type) {
1967 case SOCK_SEQPACKET:
1968 return "SequentialPacket";
1971 if (socket_address_family(&p->address) == AF_NETLINK)
1978 case SOCKET_SPECIAL:
1982 return "MessageQueue";
1992 _pure_ static bool socket_check_gc(Unit *u) {
1993 Socket *s = SOCKET(u);
1997 return s->n_connections > 0;
2000 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2001 SocketPort *p = userdata;
2007 if (p->socket->state != SOCKET_LISTENING)
2010 log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
2012 if (revents != EPOLLIN) {
2014 if (revents & EPOLLHUP)
2015 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.",
2016 UNIT(p->socket)->id);
2018 log_error_unit(UNIT(p->socket)->id, "%s: Got unexpected poll event (0x%x) on socket.",
2019 UNIT(p->socket)->id, revents);
2024 if (p->socket->accept &&
2025 p->type == SOCKET_SOCKET &&
2026 socket_address_can_accept(&p->address)) {
2030 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2036 log_error_unit(UNIT(p->socket)->id,
2037 "Failed to accept socket: %m");
2044 socket_apply_socket_options(p->socket, cfd);
2047 socket_enter_running(p->socket, cfd);
2051 socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2055 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2056 Socket *s = SOCKET(u);
2062 if (pid != s->control_pid)
2067 if (is_clean_exit(code, status, NULL))
2069 else if (code == CLD_EXITED)
2070 f = SOCKET_FAILURE_EXIT_CODE;
2071 else if (code == CLD_KILLED)
2072 f = SOCKET_FAILURE_SIGNAL;
2073 else if (code == CLD_DUMPED)
2074 f = SOCKET_FAILURE_CORE_DUMP;
2076 assert_not_reached("Unknown code");
2078 if (s->control_command) {
2079 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2081 if (s->control_command->ignore)
2085 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2087 "%s control process exited, code=%s status=%i",
2088 u->id, sigchld_code_to_string(code), status);
2090 if (f != SOCKET_SUCCESS)
2093 if (s->control_command &&
2094 s->control_command->command_next &&
2095 f == SOCKET_SUCCESS) {
2097 log_debug_unit(u->id,
2098 "%s running next command for state %s",
2099 u->id, socket_state_to_string(s->state));
2102 s->control_command = NULL;
2103 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2105 /* No further commands for this step, so let's figure
2106 * out what to do next */
2108 log_debug_unit(u->id,
2109 "%s got final SIGCHLD for state %s",
2110 u->id, socket_state_to_string(s->state));
2114 case SOCKET_START_PRE:
2115 if (f == SOCKET_SUCCESS)
2116 socket_enter_start_post(s);
2118 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2121 case SOCKET_START_POST:
2122 if (f == SOCKET_SUCCESS)
2123 socket_enter_listening(s);
2125 socket_enter_stop_pre(s, f);
2128 case SOCKET_STOP_PRE:
2129 case SOCKET_STOP_PRE_SIGTERM:
2130 case SOCKET_STOP_PRE_SIGKILL:
2131 socket_enter_stop_post(s, f);
2134 case SOCKET_STOP_POST:
2135 case SOCKET_FINAL_SIGTERM:
2136 case SOCKET_FINAL_SIGKILL:
2137 socket_enter_dead(s, f);
2141 assert_not_reached("Uh, control process died at wrong time.");
2145 /* Notify clients about changed exit status */
2146 unit_add_to_dbus_queue(u);
2149 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2150 Socket *s = SOCKET(userdata);
2153 assert(s->timer_event_source == source);
2157 case SOCKET_START_PRE:
2158 log_warning_unit(UNIT(s)->id,
2159 "%s starting timed out. Terminating.", UNIT(s)->id);
2160 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2163 case SOCKET_START_POST:
2164 log_warning_unit(UNIT(s)->id,
2165 "%s starting timed out. Stopping.", UNIT(s)->id);
2166 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2169 case SOCKET_STOP_PRE:
2170 log_warning_unit(UNIT(s)->id,
2171 "%s stopping timed out. Terminating.", UNIT(s)->id);
2172 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2175 case SOCKET_STOP_PRE_SIGTERM:
2176 if (s->kill_context.send_sigkill) {
2177 log_warning_unit(UNIT(s)->id,
2178 "%s stopping timed out. Killing.", UNIT(s)->id);
2179 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2181 log_warning_unit(UNIT(s)->id,
2182 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2184 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2188 case SOCKET_STOP_PRE_SIGKILL:
2189 log_warning_unit(UNIT(s)->id,
2190 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2191 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2194 case SOCKET_STOP_POST:
2195 log_warning_unit(UNIT(s)->id,
2196 "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2197 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2200 case SOCKET_FINAL_SIGTERM:
2201 if (s->kill_context.send_sigkill) {
2202 log_warning_unit(UNIT(s)->id,
2203 "%s stopping timed out (2). Killing.", UNIT(s)->id);
2204 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2206 log_warning_unit(UNIT(s)->id,
2207 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2209 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2213 case SOCKET_FINAL_SIGKILL:
2214 log_warning_unit(UNIT(s)->id,
2215 "%s still around after SIGKILL (2). Entering failed mode.",
2217 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2221 assert_not_reached("Timeout at wrong time.");
2227 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2236 /* Called from the service code for requesting our fds */
2239 LIST_FOREACH(port, p, s->ports)
2249 if (!(rfds = new(int, rn_fds)))
2253 LIST_FOREACH(port, p, s->ports)
2257 assert(k == rn_fds);
2265 static void socket_reset_failed(Unit *u) {
2266 Socket *s = SOCKET(u);
2270 if (s->state == SOCKET_FAILED)
2271 socket_set_state(s, SOCKET_DEAD);
2273 s->result = SOCKET_SUCCESS;
2276 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2279 /* The service is dead. Dang!
2281 * This is strictly for one-instance-for-all-connections
2284 if (s->state == SOCKET_RUNNING) {
2285 log_debug_unit(UNIT(s)->id, "%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2286 if (failed_permanent)
2287 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2289 socket_enter_listening(s);
2293 void socket_connection_unref(Socket *s) {
2296 /* The service is dead. Yay!
2298 * This is strictly for one-instance-per-connection
2301 assert(s->n_connections > 0);
2304 log_debug_unit(UNIT(s)->id, "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2307 static void socket_trigger_notify(Unit *u, Unit *other) {
2308 Socket *s = SOCKET(u);
2314 /* Don't propagate state changes from the service if we are
2315 already down or accepting connections */
2316 if ((s->state != SOCKET_RUNNING &&
2317 s->state != SOCKET_LISTENING) ||
2321 if (other->load_state != UNIT_LOADED ||
2322 other->type != UNIT_SERVICE)
2325 se = SERVICE(other);
2327 if (se->state == SERVICE_FAILED)
2328 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2330 if (se->state == SERVICE_DEAD ||
2331 se->state == SERVICE_STOP ||
2332 se->state == SERVICE_STOP_SIGTERM ||
2333 se->state == SERVICE_STOP_SIGKILL ||
2334 se->state == SERVICE_STOP_POST ||
2335 se->state == SERVICE_FINAL_SIGTERM ||
2336 se->state == SERVICE_FINAL_SIGKILL ||
2337 se->state == SERVICE_AUTO_RESTART)
2338 socket_notify_service_dead(s, false);
2340 if (se->state == SERVICE_RUNNING)
2341 socket_set_state(s, SOCKET_RUNNING);
2344 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2345 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2348 static int socket_get_timeout(Unit *u, uint64_t *timeout) {
2349 Socket *s = SOCKET(u);
2352 if (!s->timer_event_source)
2355 r = sd_event_source_get_time(s->timer_event_source, timeout);
2362 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2363 [SOCKET_DEAD] = "dead",
2364 [SOCKET_START_PRE] = "start-pre",
2365 [SOCKET_START_POST] = "start-post",
2366 [SOCKET_LISTENING] = "listening",
2367 [SOCKET_RUNNING] = "running",
2368 [SOCKET_STOP_PRE] = "stop-pre",
2369 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2370 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2371 [SOCKET_STOP_POST] = "stop-post",
2372 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2373 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2374 [SOCKET_FAILED] = "failed"
2377 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2379 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2380 [SOCKET_EXEC_START_PRE] = "StartPre",
2381 [SOCKET_EXEC_START_POST] = "StartPost",
2382 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2383 [SOCKET_EXEC_STOP_POST] = "StopPost"
2386 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2388 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2389 [SOCKET_SUCCESS] = "success",
2390 [SOCKET_FAILURE_RESOURCES] = "resources",
2391 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2392 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2393 [SOCKET_FAILURE_SIGNAL] = "signal",
2394 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2395 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2398 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2400 const UnitVTable socket_vtable = {
2401 .object_size = sizeof(Socket),
2402 .exec_context_offset = offsetof(Socket, exec_context),
2403 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2404 .kill_context_offset = offsetof(Socket, kill_context),
2405 .exec_runtime_offset = offsetof(Socket, exec_runtime),
2411 .private_section = "Socket",
2413 .init = socket_init,
2414 .done = socket_done,
2415 .load = socket_load,
2417 .coldplug = socket_coldplug,
2419 .dump = socket_dump,
2421 .start = socket_start,
2422 .stop = socket_stop,
2424 .kill = socket_kill,
2426 .get_timeout = socket_get_timeout,
2428 .serialize = socket_serialize,
2429 .deserialize_item = socket_deserialize_item,
2430 .distribute_fds = socket_distribute_fds,
2432 .active_state = socket_active_state,
2433 .sub_state_to_string = socket_sub_state_to_string,
2435 .check_gc = socket_check_gc,
2437 .sigchld_event = socket_sigchld_event,
2439 .trigger_notify = socket_trigger_notify,
2441 .reset_failed = socket_reset_failed,
2443 .bus_interface = "org.freedesktop.systemd1.Socket",
2444 .bus_vtable = bus_socket_vtable,
2445 .bus_set_property = bus_socket_set_property,
2446 .bus_commit_properties = bus_socket_commit_properties,
2448 .status_message_formats = {
2449 /*.starting_stopping = {
2450 [0] = "Starting socket %s...",
2451 [1] = "Stopping socket %s...",
2453 .finished_start_job = {
2454 [JOB_DONE] = "Listening on %s.",
2455 [JOB_FAILED] = "Failed to listen on %s.",
2456 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2457 [JOB_TIMEOUT] = "Timed out starting %s.",
2459 .finished_stop_job = {
2460 [JOB_DONE] = "Closed %s.",
2461 [JOB_FAILED] = "Failed stopping %s.",
2462 [JOB_TIMEOUT] = "Timed out stopping %s.",