1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include <sys/types.h>
27 #include <sys/epoll.h>
29 #include <arpa/inet.h>
30 #include <netinet/tcp.h>
33 #include <attr/xattr.h>
38 #include "load-dropin.h"
39 #include "load-fragment.h"
42 #include "path-util.h"
43 #include "unit-name.h"
44 #include "unit-printf.h"
48 #include "exit-status.h"
50 #include "smack-util.h"
52 #include "bus-error.h"
53 #include "dbus-socket.h"
57 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
58 [SOCKET_DEAD] = UNIT_INACTIVE,
59 [SOCKET_START_PRE] = UNIT_ACTIVATING,
60 [SOCKET_START_POST] = UNIT_ACTIVATING,
61 [SOCKET_LISTENING] = UNIT_ACTIVE,
62 [SOCKET_RUNNING] = UNIT_ACTIVE,
63 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
64 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
65 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
66 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
67 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
68 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
69 [SOCKET_FAILED] = UNIT_FAILED
72 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
73 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
75 static void socket_init(Unit *u) {
76 Socket *s = SOCKET(u);
79 assert(u->load_state == UNIT_STUB);
81 s->backlog = SOMAXCONN;
82 s->timeout_usec = u->manager->default_timeout_start_usec;
83 s->directory_mode = 0755;
84 s->socket_mode = 0666;
86 s->max_connections = 64;
93 exec_context_init(&s->exec_context);
94 s->exec_context.std_output = u->manager->default_std_output;
95 s->exec_context.std_error = u->manager->default_std_error;
96 kill_context_init(&s->kill_context);
97 cgroup_context_init(&s->cgroup_context);
99 unit_cgroup_context_init_defaults(u, &s->cgroup_context);
101 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
104 static void socket_unwatch_control_pid(Socket *s) {
107 if (s->control_pid <= 0)
110 unit_unwatch_pid(UNIT(s), s->control_pid);
114 void socket_free_ports(Socket *s) {
119 while ((p = s->ports)) {
120 LIST_REMOVE(port, s->ports, p);
122 sd_event_source_unref(p->event_source);
125 close_nointr_nofail(p->fd);
132 static void socket_done(Unit *u) {
133 Socket *s = SOCKET(u);
137 socket_free_ports(s);
139 cgroup_context_done(&s->cgroup_context);
140 exec_context_done(&s->exec_context);
141 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
142 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
143 s->control_command = NULL;
145 socket_unwatch_control_pid(s);
147 unit_ref_unset(&s->service);
149 free(s->tcp_congestion);
150 s->tcp_congestion = NULL;
152 free(s->bind_to_device);
153 s->bind_to_device = NULL;
156 free(s->smack_ip_in);
157 free(s->smack_ip_out);
159 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
162 static int socket_arm_timer(Socket *s) {
167 if (s->timeout_usec <= 0) {
168 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
172 if (s->timer_event_source) {
173 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec);
177 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
180 return sd_event_add_monotonic(UNIT(s)->manager->event, &s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec, 0, socket_dispatch_timer, s);
183 static int socket_instantiate_service(Socket *s) {
184 _cleanup_free_ char *prefix = NULL;
185 _cleanup_free_ char *name = NULL;
191 /* This fills in s->service if it isn't filled in yet. For
192 * Accept=yes sockets we create the next connection service
193 * here. For Accept=no this is mostly a NOP since the service
194 * is figured out at load time anyway. */
196 if (UNIT_DEREF(s->service))
201 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
204 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
209 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
214 #ifdef HAVE_SYSV_COMPAT
215 if (SERVICE(u)->is_sysv) {
216 log_error("Using SysV services for socket activation is not supported. Refusing.");
222 unit_ref_set(&s->service, u);
224 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
227 static bool have_non_accept_socket(Socket *s) {
235 LIST_FOREACH(port, p, s->ports) {
237 if (p->type != SOCKET_SOCKET)
240 if (!socket_address_can_accept(&p->address))
247 static int socket_add_mount_links(Socket *s) {
253 LIST_FOREACH(port, p, s->ports) {
254 const char *path = NULL;
256 if (p->type == SOCKET_SOCKET)
257 path = socket_address_get_path(&p->address);
258 else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL)
264 r = unit_require_mounts_for(UNIT(s), path);
272 static int socket_add_device_link(Socket *s) {
277 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
280 t = strappenda("/sys/subsystem/net/devices/", s->bind_to_device);
281 return unit_add_node_link(UNIT(s), t, false);
284 static int socket_add_default_dependencies(Socket *s) {
288 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
292 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
293 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
298 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
301 _pure_ static bool socket_has_exec(Socket *s) {
305 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
306 if (s->exec_command[i])
312 static int socket_add_extras(Socket *s) {
318 if (have_non_accept_socket(s)) {
320 if (!UNIT_DEREF(s->service)) {
323 r = unit_load_related_unit(u, ".service", &x);
327 unit_ref_set(&s->service, x);
330 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
335 r = socket_add_mount_links(s);
339 r = socket_add_device_link(s);
343 r = unit_exec_context_patch_defaults(u, &s->exec_context);
347 if (socket_has_exec(s)) {
348 r = unit_add_exec_dependencies(u, &s->exec_context);
352 r = unit_add_default_slice(u);
357 if (u->default_dependencies) {
358 r = socket_add_default_dependencies(s);
366 static int socket_verify(Socket *s) {
369 if (UNIT(s)->load_state != UNIT_LOADED)
373 log_error_unit(UNIT(s)->id, "%s lacks Listen setting. Refusing.", UNIT(s)->id);
377 if (s->accept && have_non_accept_socket(s)) {
378 log_error_unit(UNIT(s)->id, "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
383 if (s->accept && s->max_connections <= 0) {
384 log_error_unit(UNIT(s)->id, "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
388 if (s->accept && UNIT_DEREF(s->service)) {
389 log_error_unit(UNIT(s)->id, "Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
393 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
394 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
401 static int socket_load(Unit *u) {
402 Socket *s = SOCKET(u);
406 assert(u->load_state == UNIT_STUB);
408 r = unit_load_fragment_and_dropin(u);
412 if (u->load_state == UNIT_LOADED) {
413 /* This is a new unit? Then let's add in some extras */
414 r = socket_add_extras(s);
419 return socket_verify(s);
422 _const_ static const char* listen_lookup(int family, int type) {
424 if (family == AF_NETLINK)
425 return "ListenNetlink";
427 if (type == SOCK_STREAM)
428 return "ListenStream";
429 else if (type == SOCK_DGRAM)
430 return "ListenDatagram";
431 else if (type == SOCK_SEQPACKET)
432 return "ListenSequentialPacket";
434 assert_not_reached("Unknown socket type");
438 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
440 Socket *s = SOCKET(u);
447 prefix2 = strappenda(prefix, "\t");
450 "%sSocket State: %s\n"
452 "%sBindIPv6Only: %s\n"
454 "%sSocketMode: %04o\n"
455 "%sDirectoryMode: %04o\n"
458 "%sTransparent: %s\n"
460 "%sPassCredentials: %s\n"
461 "%sPassSecurity: %s\n"
462 "%sTCPCongestion: %s\n",
463 prefix, socket_state_to_string(s->state),
464 prefix, socket_result_to_string(s->result),
465 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
467 prefix, s->socket_mode,
468 prefix, s->directory_mode,
469 prefix, yes_no(s->keep_alive),
470 prefix, yes_no(s->free_bind),
471 prefix, yes_no(s->transparent),
472 prefix, yes_no(s->broadcast),
473 prefix, yes_no(s->pass_cred),
474 prefix, yes_no(s->pass_sec),
475 prefix, strna(s->tcp_congestion));
477 if (s->control_pid > 0)
479 "%sControl PID: %lu\n",
480 prefix, (unsigned long) s->control_pid);
482 if (s->bind_to_device)
484 "%sBindToDevice: %s\n",
485 prefix, s->bind_to_device);
490 "%sNConnections: %u\n"
491 "%sMaxConnections: %u\n",
492 prefix, s->n_accepted,
493 prefix, s->n_connections,
494 prefix, s->max_connections);
496 if (s->priority >= 0)
499 prefix, s->priority);
501 if (s->receive_buffer > 0)
503 "%sReceiveBuffer: %zu\n",
504 prefix, s->receive_buffer);
506 if (s->send_buffer > 0)
508 "%sSendBuffer: %zu\n",
509 prefix, s->send_buffer);
521 if (s->pipe_size > 0)
524 prefix, s->pipe_size);
531 if (s->mq_maxmsg > 0)
533 "%sMessageQueueMaxMessages: %li\n",
534 prefix, s->mq_maxmsg);
536 if (s->mq_msgsize > 0)
538 "%sMessageQueueMessageSize: %li\n",
539 prefix, s->mq_msgsize);
544 prefix, yes_no(s->reuse_port));
548 "%sSmackLabel: %s\n",
553 "%sSmackLabelIPIn: %s\n",
554 prefix, s->smack_ip_in);
558 "%sSmackLabelIPOut: %s\n",
559 prefix, s->smack_ip_out);
561 LIST_FOREACH(port, p, s->ports) {
563 if (p->type == SOCKET_SOCKET) {
568 if ((r = socket_address_print(&p->address, &k)) < 0)
573 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
575 } else if (p->type == SOCKET_SPECIAL)
576 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
577 else if (p->type == SOCKET_MQUEUE)
578 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
580 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
583 exec_context_dump(&s->exec_context, f, prefix);
584 kill_context_dump(&s->kill_context, f, prefix);
586 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
587 if (!s->exec_command[c])
590 fprintf(f, "%s-> %s:\n",
591 prefix, socket_exec_command_to_string(c));
593 exec_command_dump_list(s->exec_command[c], f, prefix2);
597 static int instance_from_socket(int fd, unsigned nr, char **instance) {
602 struct sockaddr_un un;
603 struct sockaddr_in in;
604 struct sockaddr_in6 in6;
605 struct sockaddr_storage storage;
612 if (getsockname(fd, &local.sa, &l) < 0)
616 if (getpeername(fd, &remote.sa, &l) < 0)
619 switch (local.sa.sa_family) {
623 a = ntohl(local.in.sin_addr.s_addr),
624 b = ntohl(remote.in.sin_addr.s_addr);
627 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
629 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
630 ntohs(local.in.sin_port),
631 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
632 ntohs(remote.in.sin_port)) < 0)
639 static const unsigned char ipv4_prefix[] = {
640 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
643 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
644 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
646 *a = local.in6.sin6_addr.s6_addr+12,
647 *b = remote.in6.sin6_addr.s6_addr+12;
650 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
652 a[0], a[1], a[2], a[3],
653 ntohs(local.in6.sin6_port),
654 b[0], b[1], b[2], b[3],
655 ntohs(remote.in6.sin6_port)) < 0)
658 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
663 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
664 ntohs(local.in6.sin6_port),
665 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
666 ntohs(remote.in6.sin6_port)) < 0)
677 k = getpeercred(fd, &ucred);
684 (unsigned long) ucred.pid,
685 (unsigned long) ucred.uid) < 0)
692 assert_not_reached("Unhandled socket type.");
699 static void socket_close_fds(Socket *s) {
704 LIST_FOREACH(port, p, s->ports) {
706 p->event_source = sd_event_source_unref(p->event_source);
711 close_nointr_nofail(p->fd);
713 /* One little note: we should never delete any sockets
714 * in the file system here! After all some other
715 * process we spawned might still have a reference of
716 * this fd and wants to continue to use it. Therefore
717 * we delete sockets in the file system before we
718 * create a new one, not after we stopped using
725 static void socket_apply_socket_options(Socket *s, int fd) {
730 int b = s->keep_alive;
731 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
732 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
737 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
738 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
743 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
744 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
749 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
750 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
753 if (s->priority >= 0)
754 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
755 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
757 if (s->receive_buffer > 0) {
758 int value = (int) s->receive_buffer;
760 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
762 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
763 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
764 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
767 if (s->send_buffer > 0) {
768 int value = (int) s->send_buffer;
769 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
770 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
771 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
775 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
776 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
779 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
780 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
782 if (s->ip_ttl >= 0) {
785 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
787 if (socket_ipv6_is_supported())
788 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
791 errno = EAFNOSUPPORT;
795 log_warning_unit(UNIT(s)->id,
796 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
799 if (s->tcp_congestion)
800 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
801 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
804 int b = s->reuse_port;
805 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)) < 0)
806 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
810 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
811 log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
814 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
815 log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
818 static void socket_apply_fifo_options(Socket *s, int fd) {
822 if (s->pipe_size > 0)
823 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
824 log_warning_unit(UNIT(s)->id,
828 if (smack_label_fd(fd, s->smack) < 0)
829 log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
832 static int fifo_address_create(
834 mode_t directory_mode,
845 mkdir_parents_label(path, directory_mode);
847 r = label_context_set(path, S_IFIFO);
851 /* Enforce the right access mode for the fifo */
852 old_mask = umask(~ socket_mode);
854 /* Include the original umask in our mask */
855 umask(~socket_mode | old_mask);
857 r = mkfifo(path, socket_mode);
860 if (r < 0 && errno != EEXIST) {
865 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
870 label_context_clear();
872 if (fstat(fd, &st) < 0) {
877 if (!S_ISFIFO(st.st_mode) ||
878 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
879 st.st_uid != getuid() ||
880 st.st_gid != getgid()) {
890 label_context_clear();
893 close_nointr_nofail(fd);
898 static int special_address_create(
908 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
913 if (fstat(fd, &st) < 0) {
918 /* Check whether this is a /proc, /sys or /dev file or char device */
919 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
929 close_nointr_nofail(fd);
934 static int mq_address_create(
944 struct mq_attr _attr, *attr = NULL;
949 if (maxmsg > 0 && msgsize > 0) {
951 _attr.mq_flags = O_NONBLOCK;
952 _attr.mq_maxmsg = maxmsg;
953 _attr.mq_msgsize = msgsize;
957 /* Enforce the right access mode for the mq */
958 old_mask = umask(~ mq_mode);
960 /* Include the original umask in our mask */
961 umask(~mq_mode | old_mask);
963 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
971 if (fstat(fd, &st) < 0) {
976 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
977 st.st_uid != getuid() ||
978 st.st_gid != getgid()) {
989 close_nointr_nofail(fd);
994 static int socket_open_fds(Socket *s) {
998 bool know_label = false;
1002 LIST_FOREACH(port, p, s->ports) {
1007 if (p->type == SOCKET_SOCKET) {
1011 if ((r = socket_instantiate_service(s)) < 0)
1014 if (UNIT_ISSET(s->service) &&
1015 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1016 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1027 r = socket_address_listen(
1029 SOCK_CLOEXEC|SOCK_NONBLOCK,
1042 socket_apply_socket_options(s, p->fd);
1044 } else if (p->type == SOCKET_SPECIAL) {
1046 r = special_address_create(
1052 } else if (p->type == SOCKET_FIFO) {
1054 r = fifo_address_create(
1062 socket_apply_fifo_options(s, p->fd);
1063 } else if (p->type == SOCKET_MQUEUE) {
1065 r = mq_address_create(
1074 assert_not_reached("Unknown port type");
1081 socket_close_fds(s);
1086 static void socket_unwatch_fds(Socket *s) {
1092 LIST_FOREACH(port, p, s->ports) {
1096 if (p->event_source) {
1097 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_OFF);
1099 log_debug_unit(UNIT(s)->id, "Failed to disable event source.");
1104 static int socket_watch_fds(Socket *s) {
1110 LIST_FOREACH(port, p, s->ports) {
1114 if (p->event_source)
1115 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1117 r = sd_event_add_io(UNIT(s)->manager->event, &p->event_source, p->fd, EPOLLIN, socket_dispatch_io, p);
1120 log_warning_unit(UNIT(s)->id, "Failed to watch listening fds: %s", strerror(-r));
1128 socket_unwatch_fds(s);
1132 static void socket_set_state(Socket *s, SocketState state) {
1133 SocketState old_state;
1136 old_state = s->state;
1139 if (state != SOCKET_START_PRE &&
1140 state != SOCKET_START_POST &&
1141 state != SOCKET_STOP_PRE &&
1142 state != SOCKET_STOP_PRE_SIGTERM &&
1143 state != SOCKET_STOP_PRE_SIGKILL &&
1144 state != SOCKET_STOP_POST &&
1145 state != SOCKET_FINAL_SIGTERM &&
1146 state != SOCKET_FINAL_SIGKILL) {
1148 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1149 socket_unwatch_control_pid(s);
1150 s->control_command = NULL;
1151 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1154 if (state != SOCKET_LISTENING)
1155 socket_unwatch_fds(s);
1157 if (state != SOCKET_START_POST &&
1158 state != SOCKET_LISTENING &&
1159 state != SOCKET_RUNNING &&
1160 state != SOCKET_STOP_PRE &&
1161 state != SOCKET_STOP_PRE_SIGTERM &&
1162 state != SOCKET_STOP_PRE_SIGKILL)
1163 socket_close_fds(s);
1165 if (state != old_state)
1166 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s",
1167 UNIT(s)->id, socket_state_to_string(old_state), socket_state_to_string(state));
1169 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1172 static int socket_coldplug(Unit *u) {
1173 Socket *s = SOCKET(u);
1177 assert(s->state == SOCKET_DEAD);
1179 if (s->deserialized_state == s->state)
1182 if (s->deserialized_state == SOCKET_START_PRE ||
1183 s->deserialized_state == SOCKET_START_POST ||
1184 s->deserialized_state == SOCKET_STOP_PRE ||
1185 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1186 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1187 s->deserialized_state == SOCKET_STOP_POST ||
1188 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1189 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1191 if (s->control_pid <= 0)
1194 r = unit_watch_pid(UNIT(s), s->control_pid);
1198 r = socket_arm_timer(s);
1203 if (s->deserialized_state == SOCKET_START_POST ||
1204 s->deserialized_state == SOCKET_LISTENING ||
1205 s->deserialized_state == SOCKET_RUNNING ||
1206 s->deserialized_state == SOCKET_STOP_PRE ||
1207 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1208 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL) {
1209 r = socket_open_fds(s);
1214 if (s->deserialized_state == SOCKET_LISTENING) {
1215 r = socket_watch_fds(s);
1220 socket_set_state(s, s->deserialized_state);
1224 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1233 unit_realize_cgroup(UNIT(s));
1235 r = unit_setup_exec_runtime(UNIT(s));
1239 r = socket_arm_timer(s);
1243 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1251 UNIT(s)->manager->environment,
1255 UNIT(s)->manager->confirm_spawn,
1256 UNIT(s)->manager->cgroup_supported,
1257 UNIT(s)->cgroup_path,
1268 r = unit_watch_pid(UNIT(s), pid);
1270 /* FIXME: we need to do something here */
1278 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1283 static void socket_enter_dead(Socket *s, SocketResult f) {
1286 if (f != SOCKET_SUCCESS)
1289 exec_runtime_destroy(s->exec_runtime);
1290 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1292 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1295 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1297 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1301 if (f != SOCKET_SUCCESS)
1304 socket_unwatch_control_pid(s);
1306 s->control_command_id = SOCKET_EXEC_STOP_POST;
1308 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1309 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1312 socket_set_state(s, SOCKET_STOP_POST);
1314 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1319 log_warning_unit(UNIT(s)->id,
1320 "%s failed to run 'stop-post' task: %s",
1321 UNIT(s)->id, strerror(-r));
1322 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1325 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1330 if (f != SOCKET_SUCCESS)
1333 r = unit_kill_context(
1336 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1344 r = socket_arm_timer(s);
1348 socket_set_state(s, state);
1349 } else if (state == SOCKET_STOP_PRE_SIGTERM)
1350 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_SUCCESS);
1351 else if (state == SOCKET_STOP_PRE_SIGKILL)
1352 socket_enter_stop_post(s, SOCKET_SUCCESS);
1353 else if (state == SOCKET_FINAL_SIGTERM)
1354 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
1356 socket_enter_dead(s, SOCKET_SUCCESS);
1361 log_warning_unit(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1363 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1364 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1366 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1369 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1373 if (f != SOCKET_SUCCESS)
1376 socket_unwatch_control_pid(s);
1378 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1380 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1381 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1384 socket_set_state(s, SOCKET_STOP_PRE);
1386 socket_enter_stop_post(s, SOCKET_SUCCESS);
1391 log_warning_unit(UNIT(s)->id, "%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1392 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1395 static void socket_enter_listening(Socket *s) {
1399 r = socket_watch_fds(s);
1401 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1405 socket_set_state(s, SOCKET_LISTENING);
1409 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1412 static void socket_enter_start_post(Socket *s) {
1416 r = socket_open_fds(s);
1418 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1422 socket_unwatch_control_pid(s);
1424 s->control_command_id = SOCKET_EXEC_START_POST;
1426 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1427 r = socket_spawn(s, s->control_command, &s->control_pid);
1429 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1433 socket_set_state(s, SOCKET_START_POST);
1435 socket_enter_listening(s);
1440 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1443 static void socket_enter_start_pre(Socket *s) {
1447 socket_unwatch_control_pid(s);
1449 s->control_command_id = SOCKET_EXEC_START_PRE;
1451 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1452 r = socket_spawn(s, s->control_command, &s->control_pid);
1456 socket_set_state(s, SOCKET_START_PRE);
1458 socket_enter_start_post(s);
1463 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1464 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1467 static void socket_enter_running(Socket *s, int cfd) {
1468 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1473 /* We don't take connections anymore if we are supposed to
1474 * shut down anyway */
1475 if (unit_stop_pending(UNIT(s))) {
1477 log_debug_unit(UNIT(s)->id, "Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1480 close_nointr_nofail(cfd);
1482 /* Flush all sockets by closing and reopening them */
1483 socket_close_fds(s);
1485 r = socket_open_fds(s);
1487 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1488 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1492 r = socket_watch_fds(s);
1494 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1495 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1505 bool pending = false;
1507 /* If there's already a start pending don't bother to
1509 SET_FOREACH(other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1510 if (unit_active_or_pending(other)) {
1516 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1521 socket_set_state(s, SOCKET_RUNNING);
1523 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1526 if (s->n_connections >= s->max_connections) {
1527 log_warning_unit(UNIT(s)->id, "%s: Too many incoming connections (%u)", UNIT(s)->id, s->n_connections);
1528 close_nointr_nofail(cfd);
1532 r = socket_instantiate_service(s);
1536 r = instance_from_socket(cfd, s->n_accepted, &instance);
1541 /* ENOTCONN is legitimate if TCP RST was received.
1542 * This connection is over, but the socket unit lives on. */
1543 close_nointr_nofail(cfd);
1547 prefix = unit_name_to_prefix(UNIT(s)->id);
1553 name = unit_name_build(prefix, instance, ".service");
1559 r = unit_add_name(UNIT_DEREF(s->service), name);
1563 service = SERVICE(UNIT_DEREF(s->service));
1564 unit_ref_unset(&s->service);
1567 UNIT(service)->no_gc = false;
1569 unit_choose_id(UNIT(service), name);
1571 r = service_set_socket_fd(service, cfd, s);
1576 s->n_connections ++;
1578 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1582 /* Notify clients about changed counters */
1583 unit_add_to_dbus_queue(UNIT(s));
1589 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",
1590 UNIT(s)->id, cfd >= 0 ? "template" : "non-template",
1591 bus_error_message(&error, r));
1593 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1596 close_nointr_nofail(cfd);
1599 static void socket_run_next(Socket *s) {
1603 assert(s->control_command);
1604 assert(s->control_command->command_next);
1606 socket_unwatch_control_pid(s);
1608 s->control_command = s->control_command->command_next;
1610 r = socket_spawn(s, s->control_command, &s->control_pid);
1617 log_warning_unit(UNIT(s)->id, "%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1619 if (s->state == SOCKET_START_POST)
1620 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1621 else if (s->state == SOCKET_STOP_POST)
1622 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1624 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1627 static int socket_start(Unit *u) {
1628 Socket *s = SOCKET(u);
1632 /* We cannot fulfill this request right now, try again later
1634 if (s->state == SOCKET_STOP_PRE ||
1635 s->state == SOCKET_STOP_PRE_SIGKILL ||
1636 s->state == SOCKET_STOP_PRE_SIGTERM ||
1637 s->state == SOCKET_STOP_POST ||
1638 s->state == SOCKET_FINAL_SIGTERM ||
1639 s->state == SOCKET_FINAL_SIGKILL)
1642 if (s->state == SOCKET_START_PRE ||
1643 s->state == SOCKET_START_POST)
1646 /* Cannot run this without the service being around */
1647 if (UNIT_ISSET(s->service)) {
1650 service = SERVICE(UNIT_DEREF(s->service));
1652 if (UNIT(service)->load_state != UNIT_LOADED) {
1653 log_error_unit(u->id, "Socket service %s not loaded, refusing.", UNIT(service)->id);
1657 /* If the service is already active we cannot start the
1659 if (service->state != SERVICE_DEAD &&
1660 service->state != SERVICE_FAILED &&
1661 service->state != SERVICE_AUTO_RESTART) {
1662 log_error_unit(u->id, "Socket service %s already active, refusing.", UNIT(service)->id);
1666 #ifdef HAVE_SYSV_COMPAT
1667 if (service->is_sysv) {
1668 log_error_unit(u->id,
1669 "Using SysV services for socket activation is not supported. Refusing.");
1675 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1677 s->result = SOCKET_SUCCESS;
1678 socket_enter_start_pre(s);
1683 static int socket_stop(Unit *u) {
1684 Socket *s = SOCKET(u);
1689 if (s->state == SOCKET_STOP_PRE ||
1690 s->state == SOCKET_STOP_PRE_SIGTERM ||
1691 s->state == SOCKET_STOP_PRE_SIGKILL ||
1692 s->state == SOCKET_STOP_POST ||
1693 s->state == SOCKET_FINAL_SIGTERM ||
1694 s->state == SOCKET_FINAL_SIGKILL)
1697 /* If there's already something running we go directly into
1699 if (s->state == SOCKET_START_PRE ||
1700 s->state == SOCKET_START_POST) {
1701 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1705 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1707 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1711 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1712 Socket *s = SOCKET(u);
1720 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1721 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1722 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1724 if (s->control_pid > 0)
1725 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1727 if (s->control_command_id >= 0)
1728 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1730 LIST_FOREACH(port, p, s->ports) {
1736 copy = fdset_put_dup(fds, p->fd);
1740 if (p->type == SOCKET_SOCKET) {
1741 _cleanup_free_ char *t = NULL;
1743 r = socket_address_print(&p->address, &t);
1747 if (socket_address_family(&p->address) == AF_NETLINK)
1748 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1750 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1752 } else if (p->type == SOCKET_SPECIAL)
1753 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1754 else if (p->type == SOCKET_MQUEUE)
1755 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1757 assert(p->type == SOCKET_FIFO);
1758 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1765 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1766 Socket *s = SOCKET(u);
1772 if (streq(key, "state")) {
1775 state = socket_state_from_string(value);
1777 log_debug_unit(u->id, "Failed to parse state value %s", value);
1779 s->deserialized_state = state;
1780 } else if (streq(key, "result")) {
1783 f = socket_result_from_string(value);
1785 log_debug_unit(u->id, "Failed to parse result value %s", value);
1786 else if (f != SOCKET_SUCCESS)
1789 } else if (streq(key, "n-accepted")) {
1792 if (safe_atou(value, &k) < 0)
1793 log_debug_unit(u->id, "Failed to parse n-accepted value %s", value);
1796 } else if (streq(key, "control-pid")) {
1799 if (parse_pid(value, &pid) < 0)
1800 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1802 s->control_pid = pid;
1803 } else if (streq(key, "control-command")) {
1804 SocketExecCommand id;
1806 id = socket_exec_command_from_string(value);
1808 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1810 s->control_command_id = id;
1811 s->control_command = s->exec_command[id];
1813 } else if (streq(key, "fifo")) {
1817 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1818 log_debug_unit(u->id, "Failed to parse fifo value %s", value);
1821 LIST_FOREACH(port, p, s->ports)
1822 if (p->type == SOCKET_FIFO &&
1823 streq_ptr(p->path, value+skip))
1828 close_nointr_nofail(p->fd);
1829 p->fd = fdset_remove(fds, fd);
1833 } else if (streq(key, "special")) {
1837 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1838 log_debug_unit(u->id, "Failed to parse special value %s", value);
1841 LIST_FOREACH(port, p, s->ports)
1842 if (p->type == SOCKET_SPECIAL &&
1843 streq_ptr(p->path, value+skip))
1848 close_nointr_nofail(p->fd);
1849 p->fd = fdset_remove(fds, fd);
1853 } else if (streq(key, "mqueue")) {
1857 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1858 log_debug_unit(u->id, "Failed to parse mqueue value %s", value);
1861 LIST_FOREACH(port, p, s->ports)
1862 if (p->type == SOCKET_MQUEUE &&
1863 streq_ptr(p->path, value+skip))
1868 close_nointr_nofail(p->fd);
1869 p->fd = fdset_remove(fds, fd);
1873 } else if (streq(key, "socket")) {
1874 int fd, type, skip = 0;
1877 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1878 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1881 LIST_FOREACH(port, p, s->ports)
1882 if (socket_address_is(&p->address, value+skip, type))
1887 close_nointr_nofail(p->fd);
1888 p->fd = fdset_remove(fds, fd);
1892 } else if (streq(key, "netlink")) {
1896 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1897 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1900 LIST_FOREACH(port, p, s->ports)
1901 if (socket_address_is_netlink(&p->address, value+skip))
1906 close_nointr_nofail(p->fd);
1907 p->fd = fdset_remove(fds, fd);
1911 log_debug_unit(UNIT(s)->id, "Unknown serialization key '%s'", key);
1916 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1917 Socket *s = SOCKET(u);
1922 LIST_FOREACH(port, p, s->ports) {
1926 if (p->type != SOCKET_SOCKET)
1932 FDSET_FOREACH(fd, fds, i) {
1933 if (socket_address_matches_fd(&p->address, fd)) {
1934 p->fd = fdset_remove(fds, fd);
1935 s->deserialized_state = SOCKET_LISTENING;
1944 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1947 return state_translation_table[SOCKET(u)->state];
1950 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1953 return socket_state_to_string(SOCKET(u)->state);
1956 const char* socket_port_type_to_string(SocketPort *p) {
1964 switch (p->address.type) {
1972 case SOCK_SEQPACKET:
1973 return "SequentialPacket";
1976 if (socket_address_family(&p->address) == AF_NETLINK)
1983 case SOCKET_SPECIAL:
1987 return "MessageQueue";
1997 _pure_ static bool socket_check_gc(Unit *u) {
1998 Socket *s = SOCKET(u);
2002 return s->n_connections > 0;
2005 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2006 SocketPort *p = userdata;
2012 if (p->socket->state != SOCKET_LISTENING)
2015 log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
2017 if (revents != EPOLLIN) {
2019 if (revents & EPOLLHUP)
2020 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.",
2021 UNIT(p->socket)->id);
2023 log_error_unit(UNIT(p->socket)->id, "%s: Got unexpected poll event (0x%x) on socket.",
2024 UNIT(p->socket)->id, revents);
2029 if (p->socket->accept &&
2030 p->type == SOCKET_SOCKET &&
2031 socket_address_can_accept(&p->address)) {
2035 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2041 log_error_unit(UNIT(p->socket)->id,
2042 "Failed to accept socket: %m");
2049 socket_apply_socket_options(p->socket, cfd);
2052 socket_enter_running(p->socket, cfd);
2056 socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2060 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2061 Socket *s = SOCKET(u);
2067 if (pid != s->control_pid)
2072 if (is_clean_exit(code, status, NULL))
2074 else if (code == CLD_EXITED)
2075 f = SOCKET_FAILURE_EXIT_CODE;
2076 else if (code == CLD_KILLED)
2077 f = SOCKET_FAILURE_SIGNAL;
2078 else if (code == CLD_DUMPED)
2079 f = SOCKET_FAILURE_CORE_DUMP;
2081 assert_not_reached("Unknown code");
2083 if (s->control_command) {
2084 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2086 if (s->control_command->ignore)
2090 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2092 "%s control process exited, code=%s status=%i",
2093 u->id, sigchld_code_to_string(code), status);
2095 if (f != SOCKET_SUCCESS)
2098 if (s->control_command &&
2099 s->control_command->command_next &&
2100 f == SOCKET_SUCCESS) {
2102 log_debug_unit(u->id,
2103 "%s running next command for state %s",
2104 u->id, socket_state_to_string(s->state));
2107 s->control_command = NULL;
2108 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2110 /* No further commands for this step, so let's figure
2111 * out what to do next */
2113 log_debug_unit(u->id,
2114 "%s got final SIGCHLD for state %s",
2115 u->id, socket_state_to_string(s->state));
2119 case SOCKET_START_PRE:
2120 if (f == SOCKET_SUCCESS)
2121 socket_enter_start_post(s);
2123 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2126 case SOCKET_START_POST:
2127 if (f == SOCKET_SUCCESS)
2128 socket_enter_listening(s);
2130 socket_enter_stop_pre(s, f);
2133 case SOCKET_STOP_PRE:
2134 case SOCKET_STOP_PRE_SIGTERM:
2135 case SOCKET_STOP_PRE_SIGKILL:
2136 socket_enter_stop_post(s, f);
2139 case SOCKET_STOP_POST:
2140 case SOCKET_FINAL_SIGTERM:
2141 case SOCKET_FINAL_SIGKILL:
2142 socket_enter_dead(s, f);
2146 assert_not_reached("Uh, control process died at wrong time.");
2150 /* Notify clients about changed exit status */
2151 unit_add_to_dbus_queue(u);
2154 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2155 Socket *s = SOCKET(userdata);
2158 assert(s->timer_event_source == source);
2162 case SOCKET_START_PRE:
2163 log_warning_unit(UNIT(s)->id,
2164 "%s starting timed out. Terminating.", UNIT(s)->id);
2165 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2168 case SOCKET_START_POST:
2169 log_warning_unit(UNIT(s)->id,
2170 "%s starting timed out. Stopping.", UNIT(s)->id);
2171 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2174 case SOCKET_STOP_PRE:
2175 log_warning_unit(UNIT(s)->id,
2176 "%s stopping timed out. Terminating.", UNIT(s)->id);
2177 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2180 case SOCKET_STOP_PRE_SIGTERM:
2181 if (s->kill_context.send_sigkill) {
2182 log_warning_unit(UNIT(s)->id,
2183 "%s stopping timed out. Killing.", UNIT(s)->id);
2184 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2186 log_warning_unit(UNIT(s)->id,
2187 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2189 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2193 case SOCKET_STOP_PRE_SIGKILL:
2194 log_warning_unit(UNIT(s)->id,
2195 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2196 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2199 case SOCKET_STOP_POST:
2200 log_warning_unit(UNIT(s)->id,
2201 "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2202 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2205 case SOCKET_FINAL_SIGTERM:
2206 if (s->kill_context.send_sigkill) {
2207 log_warning_unit(UNIT(s)->id,
2208 "%s stopping timed out (2). Killing.", UNIT(s)->id);
2209 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2211 log_warning_unit(UNIT(s)->id,
2212 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2214 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2218 case SOCKET_FINAL_SIGKILL:
2219 log_warning_unit(UNIT(s)->id,
2220 "%s still around after SIGKILL (2). Entering failed mode.",
2222 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2226 assert_not_reached("Timeout at wrong time.");
2232 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2241 /* Called from the service code for requesting our fds */
2244 LIST_FOREACH(port, p, s->ports)
2254 if (!(rfds = new(int, rn_fds)))
2258 LIST_FOREACH(port, p, s->ports)
2262 assert(k == rn_fds);
2270 static void socket_reset_failed(Unit *u) {
2271 Socket *s = SOCKET(u);
2275 if (s->state == SOCKET_FAILED)
2276 socket_set_state(s, SOCKET_DEAD);
2278 s->result = SOCKET_SUCCESS;
2281 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2284 /* The service is dead. Dang!
2286 * This is strictly for one-instance-for-all-connections
2289 if (s->state == SOCKET_RUNNING) {
2290 log_debug_unit(UNIT(s)->id, "%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2291 if (failed_permanent)
2292 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2294 socket_enter_listening(s);
2298 void socket_connection_unref(Socket *s) {
2301 /* The service is dead. Yay!
2303 * This is strictly for one-instance-per-connection
2306 assert(s->n_connections > 0);
2309 log_debug_unit(UNIT(s)->id, "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2312 static void socket_trigger_notify(Unit *u, Unit *other) {
2313 Socket *s = SOCKET(u);
2319 /* Don't propagate state changes from the service if we are
2320 already down or accepting connections */
2321 if ((s->state != SOCKET_RUNNING &&
2322 s->state != SOCKET_LISTENING) ||
2326 if (other->load_state != UNIT_LOADED ||
2327 other->type != UNIT_SERVICE)
2330 se = SERVICE(other);
2332 if (se->state == SERVICE_FAILED)
2333 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2335 if (se->state == SERVICE_DEAD ||
2336 se->state == SERVICE_STOP ||
2337 se->state == SERVICE_STOP_SIGTERM ||
2338 se->state == SERVICE_STOP_SIGKILL ||
2339 se->state == SERVICE_STOP_POST ||
2340 se->state == SERVICE_FINAL_SIGTERM ||
2341 se->state == SERVICE_FINAL_SIGKILL ||
2342 se->state == SERVICE_AUTO_RESTART)
2343 socket_notify_service_dead(s, false);
2345 if (se->state == SERVICE_RUNNING)
2346 socket_set_state(s, SOCKET_RUNNING);
2349 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2350 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2353 static int socket_get_timeout(Unit *u, uint64_t *timeout) {
2354 Socket *s = SOCKET(u);
2357 if (!s->timer_event_source)
2360 r = sd_event_source_get_time(s->timer_event_source, timeout);
2367 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2368 [SOCKET_DEAD] = "dead",
2369 [SOCKET_START_PRE] = "start-pre",
2370 [SOCKET_START_POST] = "start-post",
2371 [SOCKET_LISTENING] = "listening",
2372 [SOCKET_RUNNING] = "running",
2373 [SOCKET_STOP_PRE] = "stop-pre",
2374 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2375 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2376 [SOCKET_STOP_POST] = "stop-post",
2377 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2378 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2379 [SOCKET_FAILED] = "failed"
2382 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2384 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2385 [SOCKET_EXEC_START_PRE] = "StartPre",
2386 [SOCKET_EXEC_START_POST] = "StartPost",
2387 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2388 [SOCKET_EXEC_STOP_POST] = "StopPost"
2391 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2393 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2394 [SOCKET_SUCCESS] = "success",
2395 [SOCKET_FAILURE_RESOURCES] = "resources",
2396 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2397 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2398 [SOCKET_FAILURE_SIGNAL] = "signal",
2399 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2400 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2403 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2405 const UnitVTable socket_vtable = {
2406 .object_size = sizeof(Socket),
2407 .exec_context_offset = offsetof(Socket, exec_context),
2408 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2409 .kill_context_offset = offsetof(Socket, kill_context),
2410 .exec_runtime_offset = offsetof(Socket, exec_runtime),
2416 .private_section = "Socket",
2418 .init = socket_init,
2419 .done = socket_done,
2420 .load = socket_load,
2422 .coldplug = socket_coldplug,
2424 .dump = socket_dump,
2426 .start = socket_start,
2427 .stop = socket_stop,
2429 .kill = socket_kill,
2431 .get_timeout = socket_get_timeout,
2433 .serialize = socket_serialize,
2434 .deserialize_item = socket_deserialize_item,
2435 .distribute_fds = socket_distribute_fds,
2437 .active_state = socket_active_state,
2438 .sub_state_to_string = socket_sub_state_to_string,
2440 .check_gc = socket_check_gc,
2442 .sigchld_event = socket_sigchld_event,
2444 .trigger_notify = socket_trigger_notify,
2446 .reset_failed = socket_reset_failed,
2448 .bus_interface = "org.freedesktop.systemd1.Socket",
2449 .bus_vtable = bus_socket_vtable,
2450 .bus_set_property = bus_socket_set_property,
2451 .bus_commit_properties = bus_socket_commit_properties,
2453 .status_message_formats = {
2454 /*.starting_stopping = {
2455 [0] = "Starting socket %s...",
2456 [1] = "Stopping socket %s...",
2458 .finished_start_job = {
2459 [JOB_DONE] = "Listening on %s.",
2460 [JOB_FAILED] = "Failed to listen on %s.",
2461 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2462 [JOB_TIMEOUT] = "Timed out starting %s.",
2464 .finished_stop_job = {
2465 [JOB_DONE] = "Closed %s.",
2466 [JOB_FAILED] = "Failed stopping %s.",
2467 [JOB_TIMEOUT] = "Timed out stopping %s.",