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,
1258 manager_get_runtime_prefix(UNIT(s)->manager),
1269 r = unit_watch_pid(UNIT(s), pid);
1271 /* FIXME: we need to do something here */
1279 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1284 static void socket_enter_dead(Socket *s, SocketResult f) {
1287 if (f != SOCKET_SUCCESS)
1290 exec_runtime_destroy(s->exec_runtime);
1291 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1293 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1295 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1298 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1300 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1304 if (f != SOCKET_SUCCESS)
1307 socket_unwatch_control_pid(s);
1309 s->control_command_id = SOCKET_EXEC_STOP_POST;
1311 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1312 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1315 socket_set_state(s, SOCKET_STOP_POST);
1317 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1322 log_warning_unit(UNIT(s)->id,
1323 "%s failed to run 'stop-post' task: %s",
1324 UNIT(s)->id, strerror(-r));
1325 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1328 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1333 if (f != SOCKET_SUCCESS)
1336 r = unit_kill_context(
1339 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1347 r = socket_arm_timer(s);
1351 socket_set_state(s, state);
1352 } else if (state == SOCKET_STOP_PRE_SIGTERM)
1353 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_SUCCESS);
1354 else if (state == SOCKET_STOP_PRE_SIGKILL)
1355 socket_enter_stop_post(s, SOCKET_SUCCESS);
1356 else if (state == SOCKET_FINAL_SIGTERM)
1357 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
1359 socket_enter_dead(s, SOCKET_SUCCESS);
1364 log_warning_unit(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1366 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1367 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1369 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1372 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1376 if (f != SOCKET_SUCCESS)
1379 socket_unwatch_control_pid(s);
1381 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1383 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1384 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1387 socket_set_state(s, SOCKET_STOP_PRE);
1389 socket_enter_stop_post(s, SOCKET_SUCCESS);
1394 log_warning_unit(UNIT(s)->id, "%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1395 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1398 static void socket_enter_listening(Socket *s) {
1402 r = socket_watch_fds(s);
1404 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1408 socket_set_state(s, SOCKET_LISTENING);
1412 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1415 static void socket_enter_start_post(Socket *s) {
1419 r = socket_open_fds(s);
1421 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1425 socket_unwatch_control_pid(s);
1427 s->control_command_id = SOCKET_EXEC_START_POST;
1429 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1430 r = socket_spawn(s, s->control_command, &s->control_pid);
1432 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1436 socket_set_state(s, SOCKET_START_POST);
1438 socket_enter_listening(s);
1443 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1446 static void socket_enter_start_pre(Socket *s) {
1450 socket_unwatch_control_pid(s);
1452 s->control_command_id = SOCKET_EXEC_START_PRE;
1454 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1455 r = socket_spawn(s, s->control_command, &s->control_pid);
1459 socket_set_state(s, SOCKET_START_PRE);
1461 socket_enter_start_post(s);
1466 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1467 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1470 static void socket_enter_running(Socket *s, int cfd) {
1471 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1476 /* We don't take connections anymore if we are supposed to
1477 * shut down anyway */
1478 if (unit_stop_pending(UNIT(s))) {
1480 log_debug_unit(UNIT(s)->id, "Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1483 close_nointr_nofail(cfd);
1485 /* Flush all sockets by closing and reopening them */
1486 socket_close_fds(s);
1488 r = socket_open_fds(s);
1490 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1491 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1495 r = socket_watch_fds(s);
1497 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1498 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1508 bool pending = false;
1510 /* If there's already a start pending don't bother to
1512 SET_FOREACH(other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1513 if (unit_active_or_pending(other)) {
1519 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1524 socket_set_state(s, SOCKET_RUNNING);
1526 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1529 if (s->n_connections >= s->max_connections) {
1530 log_warning_unit(UNIT(s)->id, "%s: Too many incoming connections (%u)", UNIT(s)->id, s->n_connections);
1531 close_nointr_nofail(cfd);
1535 r = socket_instantiate_service(s);
1539 r = instance_from_socket(cfd, s->n_accepted, &instance);
1544 /* ENOTCONN is legitimate if TCP RST was received.
1545 * This connection is over, but the socket unit lives on. */
1546 close_nointr_nofail(cfd);
1550 prefix = unit_name_to_prefix(UNIT(s)->id);
1556 name = unit_name_build(prefix, instance, ".service");
1562 r = unit_add_name(UNIT_DEREF(s->service), name);
1566 service = SERVICE(UNIT_DEREF(s->service));
1567 unit_ref_unset(&s->service);
1570 UNIT(service)->no_gc = false;
1572 unit_choose_id(UNIT(service), name);
1574 r = service_set_socket_fd(service, cfd, s);
1579 s->n_connections ++;
1581 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1585 /* Notify clients about changed counters */
1586 unit_add_to_dbus_queue(UNIT(s));
1592 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",
1593 UNIT(s)->id, cfd >= 0 ? "template" : "non-template",
1594 bus_error_message(&error, r));
1596 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1599 close_nointr_nofail(cfd);
1602 static void socket_run_next(Socket *s) {
1606 assert(s->control_command);
1607 assert(s->control_command->command_next);
1609 socket_unwatch_control_pid(s);
1611 s->control_command = s->control_command->command_next;
1613 r = socket_spawn(s, s->control_command, &s->control_pid);
1620 log_warning_unit(UNIT(s)->id, "%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1622 if (s->state == SOCKET_START_POST)
1623 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1624 else if (s->state == SOCKET_STOP_POST)
1625 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1627 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1630 static int socket_start(Unit *u) {
1631 Socket *s = SOCKET(u);
1635 /* We cannot fulfill this request right now, try again later
1637 if (s->state == SOCKET_STOP_PRE ||
1638 s->state == SOCKET_STOP_PRE_SIGKILL ||
1639 s->state == SOCKET_STOP_PRE_SIGTERM ||
1640 s->state == SOCKET_STOP_POST ||
1641 s->state == SOCKET_FINAL_SIGTERM ||
1642 s->state == SOCKET_FINAL_SIGKILL)
1645 if (s->state == SOCKET_START_PRE ||
1646 s->state == SOCKET_START_POST)
1649 /* Cannot run this without the service being around */
1650 if (UNIT_ISSET(s->service)) {
1653 service = SERVICE(UNIT_DEREF(s->service));
1655 if (UNIT(service)->load_state != UNIT_LOADED) {
1656 log_error_unit(u->id, "Socket service %s not loaded, refusing.", UNIT(service)->id);
1660 /* If the service is already active we cannot start the
1662 if (service->state != SERVICE_DEAD &&
1663 service->state != SERVICE_FAILED &&
1664 service->state != SERVICE_AUTO_RESTART) {
1665 log_error_unit(u->id, "Socket service %s already active, refusing.", UNIT(service)->id);
1669 #ifdef HAVE_SYSV_COMPAT
1670 if (service->is_sysv) {
1671 log_error_unit(u->id,
1672 "Using SysV services for socket activation is not supported. Refusing.");
1678 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1680 s->result = SOCKET_SUCCESS;
1681 socket_enter_start_pre(s);
1686 static int socket_stop(Unit *u) {
1687 Socket *s = SOCKET(u);
1692 if (s->state == SOCKET_STOP_PRE ||
1693 s->state == SOCKET_STOP_PRE_SIGTERM ||
1694 s->state == SOCKET_STOP_PRE_SIGKILL ||
1695 s->state == SOCKET_STOP_POST ||
1696 s->state == SOCKET_FINAL_SIGTERM ||
1697 s->state == SOCKET_FINAL_SIGKILL)
1700 /* If there's already something running we go directly into
1702 if (s->state == SOCKET_START_PRE ||
1703 s->state == SOCKET_START_POST) {
1704 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1708 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1710 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1714 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1715 Socket *s = SOCKET(u);
1723 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1724 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1725 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1727 if (s->control_pid > 0)
1728 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1730 if (s->control_command_id >= 0)
1731 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1733 LIST_FOREACH(port, p, s->ports) {
1739 copy = fdset_put_dup(fds, p->fd);
1743 if (p->type == SOCKET_SOCKET) {
1744 _cleanup_free_ char *t = NULL;
1746 r = socket_address_print(&p->address, &t);
1750 if (socket_address_family(&p->address) == AF_NETLINK)
1751 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1753 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1755 } else if (p->type == SOCKET_SPECIAL)
1756 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1757 else if (p->type == SOCKET_MQUEUE)
1758 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1760 assert(p->type == SOCKET_FIFO);
1761 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1768 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1769 Socket *s = SOCKET(u);
1775 if (streq(key, "state")) {
1778 state = socket_state_from_string(value);
1780 log_debug_unit(u->id, "Failed to parse state value %s", value);
1782 s->deserialized_state = state;
1783 } else if (streq(key, "result")) {
1786 f = socket_result_from_string(value);
1788 log_debug_unit(u->id, "Failed to parse result value %s", value);
1789 else if (f != SOCKET_SUCCESS)
1792 } else if (streq(key, "n-accepted")) {
1795 if (safe_atou(value, &k) < 0)
1796 log_debug_unit(u->id, "Failed to parse n-accepted value %s", value);
1799 } else if (streq(key, "control-pid")) {
1802 if (parse_pid(value, &pid) < 0)
1803 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1805 s->control_pid = pid;
1806 } else if (streq(key, "control-command")) {
1807 SocketExecCommand id;
1809 id = socket_exec_command_from_string(value);
1811 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1813 s->control_command_id = id;
1814 s->control_command = s->exec_command[id];
1816 } else if (streq(key, "fifo")) {
1820 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1821 log_debug_unit(u->id, "Failed to parse fifo value %s", value);
1824 LIST_FOREACH(port, p, s->ports)
1825 if (p->type == SOCKET_FIFO &&
1826 streq_ptr(p->path, value+skip))
1831 close_nointr_nofail(p->fd);
1832 p->fd = fdset_remove(fds, fd);
1836 } else if (streq(key, "special")) {
1840 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1841 log_debug_unit(u->id, "Failed to parse special value %s", value);
1844 LIST_FOREACH(port, p, s->ports)
1845 if (p->type == SOCKET_SPECIAL &&
1846 streq_ptr(p->path, value+skip))
1851 close_nointr_nofail(p->fd);
1852 p->fd = fdset_remove(fds, fd);
1856 } else if (streq(key, "mqueue")) {
1860 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1861 log_debug_unit(u->id, "Failed to parse mqueue value %s", value);
1864 LIST_FOREACH(port, p, s->ports)
1865 if (p->type == SOCKET_MQUEUE &&
1866 streq_ptr(p->path, value+skip))
1871 close_nointr_nofail(p->fd);
1872 p->fd = fdset_remove(fds, fd);
1876 } else if (streq(key, "socket")) {
1877 int fd, type, skip = 0;
1880 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1881 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1884 LIST_FOREACH(port, p, s->ports)
1885 if (socket_address_is(&p->address, value+skip, type))
1890 close_nointr_nofail(p->fd);
1891 p->fd = fdset_remove(fds, fd);
1895 } else if (streq(key, "netlink")) {
1899 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1900 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1903 LIST_FOREACH(port, p, s->ports)
1904 if (socket_address_is_netlink(&p->address, value+skip))
1909 close_nointr_nofail(p->fd);
1910 p->fd = fdset_remove(fds, fd);
1914 log_debug_unit(UNIT(s)->id, "Unknown serialization key '%s'", key);
1919 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1920 Socket *s = SOCKET(u);
1925 LIST_FOREACH(port, p, s->ports) {
1929 if (p->type != SOCKET_SOCKET)
1935 FDSET_FOREACH(fd, fds, i) {
1936 if (socket_address_matches_fd(&p->address, fd)) {
1937 p->fd = fdset_remove(fds, fd);
1938 s->deserialized_state = SOCKET_LISTENING;
1947 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1950 return state_translation_table[SOCKET(u)->state];
1953 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1956 return socket_state_to_string(SOCKET(u)->state);
1959 const char* socket_port_type_to_string(SocketPort *p) {
1967 switch (p->address.type) {
1975 case SOCK_SEQPACKET:
1976 return "SequentialPacket";
1979 if (socket_address_family(&p->address) == AF_NETLINK)
1986 case SOCKET_SPECIAL:
1990 return "MessageQueue";
2000 _pure_ static bool socket_check_gc(Unit *u) {
2001 Socket *s = SOCKET(u);
2005 return s->n_connections > 0;
2008 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2009 SocketPort *p = userdata;
2015 if (p->socket->state != SOCKET_LISTENING)
2018 log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
2020 if (revents != EPOLLIN) {
2022 if (revents & EPOLLHUP)
2023 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.",
2024 UNIT(p->socket)->id);
2026 log_error_unit(UNIT(p->socket)->id, "%s: Got unexpected poll event (0x%x) on socket.",
2027 UNIT(p->socket)->id, revents);
2032 if (p->socket->accept &&
2033 p->type == SOCKET_SOCKET &&
2034 socket_address_can_accept(&p->address)) {
2038 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2044 log_error_unit(UNIT(p->socket)->id,
2045 "Failed to accept socket: %m");
2052 socket_apply_socket_options(p->socket, cfd);
2055 socket_enter_running(p->socket, cfd);
2059 socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2063 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2064 Socket *s = SOCKET(u);
2070 if (pid != s->control_pid)
2075 if (is_clean_exit(code, status, NULL))
2077 else if (code == CLD_EXITED)
2078 f = SOCKET_FAILURE_EXIT_CODE;
2079 else if (code == CLD_KILLED)
2080 f = SOCKET_FAILURE_SIGNAL;
2081 else if (code == CLD_DUMPED)
2082 f = SOCKET_FAILURE_CORE_DUMP;
2084 assert_not_reached("Unknown code");
2086 if (s->control_command) {
2087 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2089 if (s->control_command->ignore)
2093 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2095 "%s control process exited, code=%s status=%i",
2096 u->id, sigchld_code_to_string(code), status);
2098 if (f != SOCKET_SUCCESS)
2101 if (s->control_command &&
2102 s->control_command->command_next &&
2103 f == SOCKET_SUCCESS) {
2105 log_debug_unit(u->id,
2106 "%s running next command for state %s",
2107 u->id, socket_state_to_string(s->state));
2110 s->control_command = NULL;
2111 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2113 /* No further commands for this step, so let's figure
2114 * out what to do next */
2116 log_debug_unit(u->id,
2117 "%s got final SIGCHLD for state %s",
2118 u->id, socket_state_to_string(s->state));
2122 case SOCKET_START_PRE:
2123 if (f == SOCKET_SUCCESS)
2124 socket_enter_start_post(s);
2126 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2129 case SOCKET_START_POST:
2130 if (f == SOCKET_SUCCESS)
2131 socket_enter_listening(s);
2133 socket_enter_stop_pre(s, f);
2136 case SOCKET_STOP_PRE:
2137 case SOCKET_STOP_PRE_SIGTERM:
2138 case SOCKET_STOP_PRE_SIGKILL:
2139 socket_enter_stop_post(s, f);
2142 case SOCKET_STOP_POST:
2143 case SOCKET_FINAL_SIGTERM:
2144 case SOCKET_FINAL_SIGKILL:
2145 socket_enter_dead(s, f);
2149 assert_not_reached("Uh, control process died at wrong time.");
2153 /* Notify clients about changed exit status */
2154 unit_add_to_dbus_queue(u);
2157 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2158 Socket *s = SOCKET(userdata);
2161 assert(s->timer_event_source == source);
2165 case SOCKET_START_PRE:
2166 log_warning_unit(UNIT(s)->id,
2167 "%s starting timed out. Terminating.", UNIT(s)->id);
2168 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2171 case SOCKET_START_POST:
2172 log_warning_unit(UNIT(s)->id,
2173 "%s starting timed out. Stopping.", UNIT(s)->id);
2174 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2177 case SOCKET_STOP_PRE:
2178 log_warning_unit(UNIT(s)->id,
2179 "%s stopping timed out. Terminating.", UNIT(s)->id);
2180 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2183 case SOCKET_STOP_PRE_SIGTERM:
2184 if (s->kill_context.send_sigkill) {
2185 log_warning_unit(UNIT(s)->id,
2186 "%s stopping timed out. Killing.", UNIT(s)->id);
2187 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2189 log_warning_unit(UNIT(s)->id,
2190 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2192 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2196 case SOCKET_STOP_PRE_SIGKILL:
2197 log_warning_unit(UNIT(s)->id,
2198 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2199 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2202 case SOCKET_STOP_POST:
2203 log_warning_unit(UNIT(s)->id,
2204 "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2205 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2208 case SOCKET_FINAL_SIGTERM:
2209 if (s->kill_context.send_sigkill) {
2210 log_warning_unit(UNIT(s)->id,
2211 "%s stopping timed out (2). Killing.", UNIT(s)->id);
2212 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2214 log_warning_unit(UNIT(s)->id,
2215 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2217 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2221 case SOCKET_FINAL_SIGKILL:
2222 log_warning_unit(UNIT(s)->id,
2223 "%s still around after SIGKILL (2). Entering failed mode.",
2225 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2229 assert_not_reached("Timeout at wrong time.");
2235 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2244 /* Called from the service code for requesting our fds */
2247 LIST_FOREACH(port, p, s->ports)
2257 if (!(rfds = new(int, rn_fds)))
2261 LIST_FOREACH(port, p, s->ports)
2265 assert(k == rn_fds);
2273 static void socket_reset_failed(Unit *u) {
2274 Socket *s = SOCKET(u);
2278 if (s->state == SOCKET_FAILED)
2279 socket_set_state(s, SOCKET_DEAD);
2281 s->result = SOCKET_SUCCESS;
2284 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2287 /* The service is dead. Dang!
2289 * This is strictly for one-instance-for-all-connections
2292 if (s->state == SOCKET_RUNNING) {
2293 log_debug_unit(UNIT(s)->id, "%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2294 if (failed_permanent)
2295 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2297 socket_enter_listening(s);
2301 void socket_connection_unref(Socket *s) {
2304 /* The service is dead. Yay!
2306 * This is strictly for one-instance-per-connection
2309 assert(s->n_connections > 0);
2312 log_debug_unit(UNIT(s)->id, "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2315 static void socket_trigger_notify(Unit *u, Unit *other) {
2316 Socket *s = SOCKET(u);
2322 /* Don't propagate state changes from the service if we are
2323 already down or accepting connections */
2324 if ((s->state != SOCKET_RUNNING &&
2325 s->state != SOCKET_LISTENING) ||
2329 if (other->load_state != UNIT_LOADED ||
2330 other->type != UNIT_SERVICE)
2333 se = SERVICE(other);
2335 if (se->state == SERVICE_FAILED)
2336 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2338 if (se->state == SERVICE_DEAD ||
2339 se->state == SERVICE_STOP ||
2340 se->state == SERVICE_STOP_SIGTERM ||
2341 se->state == SERVICE_STOP_SIGKILL ||
2342 se->state == SERVICE_STOP_POST ||
2343 se->state == SERVICE_FINAL_SIGTERM ||
2344 se->state == SERVICE_FINAL_SIGKILL ||
2345 se->state == SERVICE_AUTO_RESTART)
2346 socket_notify_service_dead(s, false);
2348 if (se->state == SERVICE_RUNNING)
2349 socket_set_state(s, SOCKET_RUNNING);
2352 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2353 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2356 static int socket_get_timeout(Unit *u, uint64_t *timeout) {
2357 Socket *s = SOCKET(u);
2360 if (!s->timer_event_source)
2363 r = sd_event_source_get_time(s->timer_event_source, timeout);
2370 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2371 [SOCKET_DEAD] = "dead",
2372 [SOCKET_START_PRE] = "start-pre",
2373 [SOCKET_START_POST] = "start-post",
2374 [SOCKET_LISTENING] = "listening",
2375 [SOCKET_RUNNING] = "running",
2376 [SOCKET_STOP_PRE] = "stop-pre",
2377 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2378 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2379 [SOCKET_STOP_POST] = "stop-post",
2380 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2381 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2382 [SOCKET_FAILED] = "failed"
2385 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2387 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2388 [SOCKET_EXEC_START_PRE] = "StartPre",
2389 [SOCKET_EXEC_START_POST] = "StartPost",
2390 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2391 [SOCKET_EXEC_STOP_POST] = "StopPost"
2394 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2396 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2397 [SOCKET_SUCCESS] = "success",
2398 [SOCKET_FAILURE_RESOURCES] = "resources",
2399 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2400 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2401 [SOCKET_FAILURE_SIGNAL] = "signal",
2402 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2403 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2406 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2408 const UnitVTable socket_vtable = {
2409 .object_size = sizeof(Socket),
2410 .exec_context_offset = offsetof(Socket, exec_context),
2411 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2412 .kill_context_offset = offsetof(Socket, kill_context),
2413 .exec_runtime_offset = offsetof(Socket, exec_runtime),
2419 .private_section = "Socket",
2421 .init = socket_init,
2422 .done = socket_done,
2423 .load = socket_load,
2425 .coldplug = socket_coldplug,
2427 .dump = socket_dump,
2429 .start = socket_start,
2430 .stop = socket_stop,
2432 .kill = socket_kill,
2434 .get_timeout = socket_get_timeout,
2436 .serialize = socket_serialize,
2437 .deserialize_item = socket_deserialize_item,
2438 .distribute_fds = socket_distribute_fds,
2440 .active_state = socket_active_state,
2441 .sub_state_to_string = socket_sub_state_to_string,
2443 .check_gc = socket_check_gc,
2445 .sigchld_event = socket_sigchld_event,
2447 .trigger_notify = socket_trigger_notify,
2449 .reset_failed = socket_reset_failed,
2451 .bus_interface = "org.freedesktop.systemd1.Socket",
2452 .bus_vtable = bus_socket_vtable,
2453 .bus_set_property = bus_socket_set_property,
2454 .bus_commit_properties = bus_socket_commit_properties,
2456 .status_message_formats = {
2457 /*.starting_stopping = {
2458 [0] = "Starting socket %s...",
2459 [1] = "Stopping socket %s...",
2461 .finished_start_job = {
2462 [JOB_DONE] = "Listening on %s.",
2463 [JOB_FAILED] = "Failed to listen on %s.",
2464 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2465 [JOB_TIMEOUT] = "Timed out starting %s.",
2467 .finished_stop_job = {
2468 [JOB_DONE] = "Closed %s.",
2469 [JOB_FAILED] = "Failed stopping %s.",
2470 [JOB_TIMEOUT] = "Timed out stopping %s.",