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>
31 #ifdef HAVE_ATTR_XATTR_H
32 #include <attr/xattr.h>
37 #include "netinet/tcp.h"
39 #include "load-dropin.h"
40 #include "load-fragment.h"
43 #include "path-util.h"
44 #include "unit-name.h"
45 #include "unit-printf.h"
46 #include "dbus-socket.h"
49 #include "bus-errors.h"
51 #include "exit-status.h"
54 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
55 [SOCKET_DEAD] = UNIT_INACTIVE,
56 [SOCKET_START_PRE] = UNIT_ACTIVATING,
57 [SOCKET_START_POST] = UNIT_ACTIVATING,
58 [SOCKET_LISTENING] = UNIT_ACTIVE,
59 [SOCKET_RUNNING] = UNIT_ACTIVE,
60 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
61 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
62 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
63 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
64 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
65 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
66 [SOCKET_FAILED] = UNIT_FAILED
69 static void socket_init(Unit *u) {
70 Socket *s = SOCKET(u);
73 assert(u->load_state == UNIT_STUB);
75 s->backlog = SOMAXCONN;
76 s->timeout_usec = DEFAULT_TIMEOUT_USEC;
77 s->directory_mode = 0755;
78 s->socket_mode = 0666;
80 s->max_connections = 64;
87 exec_context_init(&s->exec_context);
88 s->exec_context.std_output = u->manager->default_std_output;
89 s->exec_context.std_error = u->manager->default_std_error;
90 kill_context_init(&s->kill_context);
92 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
95 static void socket_unwatch_control_pid(Socket *s) {
98 if (s->control_pid <= 0)
101 unit_unwatch_pid(UNIT(s), s->control_pid);
105 void socket_free_ports(Socket *s) {
110 while ((p = s->ports)) {
111 LIST_REMOVE(SocketPort, port, s->ports, p);
114 unit_unwatch_fd(UNIT(s), &p->fd_watch);
115 close_nointr_nofail(p->fd);
123 static void socket_done(Unit *u) {
124 Socket *s = SOCKET(u);
128 socket_free_ports(s);
130 exec_context_done(&s->exec_context, manager_is_reloading_or_reexecuting(u->manager));
131 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
132 s->control_command = NULL;
134 socket_unwatch_control_pid(s);
136 unit_ref_unset(&s->service);
138 free(s->tcp_congestion);
139 s->tcp_congestion = NULL;
141 free(s->bind_to_device);
142 s->bind_to_device = NULL;
145 free(s->smack_ip_in);
146 free(s->smack_ip_out);
148 unit_unwatch_timer(u, &s->timer_watch);
151 static int socket_instantiate_service(Socket *s) {
158 /* This fills in s->service if it isn't filled in yet. For
159 * Accept=yes sockets we create the next connection service
160 * here. For Accept=no this is mostly a NOP since the service
161 * is figured out at load time anyway. */
163 if (UNIT_DEREF(s->service))
168 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
171 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
177 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
183 #ifdef HAVE_SYSV_COMPAT
184 if (SERVICE(u)->is_sysv) {
185 log_error("Using SysV services for socket activation is not supported. Refusing.");
191 unit_ref_set(&s->service, u);
193 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
196 static bool have_non_accept_socket(Socket *s) {
204 LIST_FOREACH(port, p, s->ports) {
206 if (p->type != SOCKET_SOCKET)
209 if (!socket_address_can_accept(&p->address))
216 static int socket_verify(Socket *s) {
219 if (UNIT(s)->load_state != UNIT_LOADED)
223 log_error_unit(UNIT(s)->id,
224 "%s lacks Listen setting. Refusing.", UNIT(s)->id);
228 if (s->accept && have_non_accept_socket(s)) {
229 log_error_unit(UNIT(s)->id,
230 "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
235 if (s->accept && s->max_connections <= 0) {
236 log_error_unit(UNIT(s)->id,
237 "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
241 if (s->accept && UNIT_DEREF(s->service)) {
242 log_error_unit(UNIT(s)->id,
243 "Explicit service configuration for accepting sockets not supported on %s. Refusing.",
248 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
249 log_error_unit(UNIT(s)->id,
250 "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.",
258 static bool socket_needs_mount(Socket *s, const char *prefix) {
263 LIST_FOREACH(port, p, s->ports) {
265 if (p->type == SOCKET_SOCKET) {
266 if (socket_address_needs_mount(&p->address, prefix))
268 } else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL) {
269 if (path_startswith(p->path, prefix))
277 int socket_add_one_mount_link(Socket *s, Mount *m) {
283 if (UNIT(s)->load_state != UNIT_LOADED ||
284 UNIT(m)->load_state != UNIT_LOADED)
287 if (!socket_needs_mount(s, m->where))
290 r = unit_add_two_dependencies(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
297 static int socket_add_mount_links(Socket *s) {
303 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_MOUNT]) {
304 r = socket_add_one_mount_link(s, MOUNT(other));
312 static int socket_add_device_link(Socket *s) {
318 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
321 if (asprintf(&t, "/sys/subsystem/net/devices/%s", s->bind_to_device) < 0)
324 r = unit_add_node_link(UNIT(s), t, false);
330 static int socket_add_default_dependencies(Socket *s) {
334 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
338 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
339 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
344 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
347 static bool socket_has_exec(Socket *s) {
351 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
352 if (s->exec_command[i])
358 static int socket_load(Unit *u) {
359 Socket *s = SOCKET(u);
363 assert(u->load_state == UNIT_STUB);
365 if ((r = unit_load_fragment_and_dropin(u)) < 0)
368 /* This is a new unit? Then let's add in some extras */
369 if (u->load_state == UNIT_LOADED) {
371 if (have_non_accept_socket(s)) {
373 if (!UNIT_DEREF(s->service)) {
376 r = unit_load_related_unit(u, ".service", &x);
380 unit_ref_set(&s->service, x);
383 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
388 if ((r = socket_add_mount_links(s)) < 0)
391 if ((r = socket_add_device_link(s)) < 0)
394 if (socket_has_exec(s))
395 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
398 if ((r = unit_add_default_cgroups(u)) < 0)
401 if (UNIT(s)->default_dependencies)
402 if ((r = socket_add_default_dependencies(s)) < 0)
405 r = unit_exec_context_defaults(u, &s->exec_context);
410 return socket_verify(s);
413 static const char* listen_lookup(int family, int type) {
415 if (family == AF_NETLINK)
416 return "ListenNetlink";
418 if (type == SOCK_STREAM)
419 return "ListenStream";
420 else if (type == SOCK_DGRAM)
421 return "ListenDatagram";
422 else if (type == SOCK_SEQPACKET)
423 return "ListenSequentialPacket";
425 assert_not_reached("Unknown socket type");
429 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
432 Socket *s = SOCKET(u);
440 p2 = strappend(prefix, "\t");
441 prefix2 = p2 ? p2 : prefix;
444 "%sSocket State: %s\n"
446 "%sBindIPv6Only: %s\n"
448 "%sSocketMode: %04o\n"
449 "%sDirectoryMode: %04o\n"
452 "%sTransparent: %s\n"
454 "%sPassCredentials: %s\n"
455 "%sPassSecurity: %s\n"
456 "%sTCPCongestion: %s\n",
457 prefix, socket_state_to_string(s->state),
458 prefix, socket_result_to_string(s->result),
459 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
461 prefix, s->socket_mode,
462 prefix, s->directory_mode,
463 prefix, yes_no(s->keep_alive),
464 prefix, yes_no(s->free_bind),
465 prefix, yes_no(s->transparent),
466 prefix, yes_no(s->broadcast),
467 prefix, yes_no(s->pass_cred),
468 prefix, yes_no(s->pass_sec),
469 prefix, strna(s->tcp_congestion));
471 if (s->control_pid > 0)
473 "%sControl PID: %lu\n",
474 prefix, (unsigned long) s->control_pid);
476 if (s->bind_to_device)
478 "%sBindToDevice: %s\n",
479 prefix, s->bind_to_device);
484 "%sNConnections: %u\n"
485 "%sMaxConnections: %u\n",
486 prefix, s->n_accepted,
487 prefix, s->n_connections,
488 prefix, s->max_connections);
490 if (s->priority >= 0)
493 prefix, s->priority);
495 if (s->receive_buffer > 0)
497 "%sReceiveBuffer: %zu\n",
498 prefix, s->receive_buffer);
500 if (s->send_buffer > 0)
502 "%sSendBuffer: %zu\n",
503 prefix, s->send_buffer);
515 if (s->pipe_size > 0)
518 prefix, s->pipe_size);
525 if (s->mq_maxmsg > 0)
527 "%sMessageQueueMaxMessages: %li\n",
528 prefix, s->mq_maxmsg);
530 if (s->mq_msgsize > 0)
532 "%sMessageQueueMessageSize: %li\n",
533 prefix, s->mq_msgsize);
537 "%sSmackLabel: %s\n",
542 "%sSmackLabelIPIn: %s\n",
543 prefix, s->smack_ip_in);
547 "%sSmackLabelIPOut: %s\n",
548 prefix, s->smack_ip_out);
550 LIST_FOREACH(port, p, s->ports) {
552 if (p->type == SOCKET_SOCKET) {
557 if ((r = socket_address_print(&p->address, &k)) < 0)
562 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
564 } else if (p->type == SOCKET_SPECIAL)
565 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
566 else if (p->type == SOCKET_MQUEUE)
567 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
569 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
572 exec_context_dump(&s->exec_context, f, prefix);
573 kill_context_dump(&s->kill_context, f, prefix);
575 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
576 if (!s->exec_command[c])
579 fprintf(f, "%s-> %s:\n",
580 prefix, socket_exec_command_to_string(c));
582 exec_command_dump_list(s->exec_command[c], f, prefix2);
588 static int instance_from_socket(int fd, unsigned nr, char **instance) {
593 struct sockaddr_un un;
594 struct sockaddr_in in;
595 struct sockaddr_in6 in6;
596 struct sockaddr_storage storage;
603 if (getsockname(fd, &local.sa, &l) < 0)
607 if (getpeername(fd, &remote.sa, &l) < 0)
610 switch (local.sa.sa_family) {
614 a = ntohl(local.in.sin_addr.s_addr),
615 b = ntohl(remote.in.sin_addr.s_addr);
618 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
620 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
621 ntohs(local.in.sin_port),
622 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
623 ntohs(remote.in.sin_port)) < 0)
630 static const unsigned char ipv4_prefix[] = {
631 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
634 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
635 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
637 *a = local.in6.sin6_addr.s6_addr+12,
638 *b = remote.in6.sin6_addr.s6_addr+12;
641 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
643 a[0], a[1], a[2], a[3],
644 ntohs(local.in6.sin6_port),
645 b[0], b[1], b[2], b[3],
646 ntohs(remote.in6.sin6_port)) < 0)
649 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
654 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
655 ntohs(local.in6.sin6_port),
656 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
657 ntohs(remote.in6.sin6_port)) < 0)
668 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
674 (unsigned long) ucred.pid,
675 (unsigned long) ucred.uid) < 0)
682 assert_not_reached("Unhandled socket type.");
689 static void socket_close_fds(Socket *s) {
694 LIST_FOREACH(port, p, s->ports) {
698 unit_unwatch_fd(UNIT(s), &p->fd_watch);
699 close_nointr_nofail(p->fd);
701 /* One little note: we should never delete any sockets
702 * in the file system here! After all some other
703 * process we spawned might still have a reference of
704 * this fd and wants to continue to use it. Therefore
705 * we delete sockets in the file system before we
706 * create a new one, not after we stopped using
713 static void socket_apply_socket_options(Socket *s, int fd) {
718 int b = s->keep_alive;
719 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
720 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
725 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
726 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
731 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
732 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
737 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
738 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
741 if (s->priority >= 0)
742 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
743 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
745 if (s->receive_buffer > 0) {
746 int value = (int) s->receive_buffer;
748 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
750 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
751 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
752 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
755 if (s->send_buffer > 0) {
756 int value = (int) s->send_buffer;
757 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
758 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
759 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
763 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
764 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
767 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
768 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
770 if (s->ip_ttl >= 0) {
773 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
775 if (socket_ipv6_is_supported())
776 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
779 errno = EAFNOSUPPORT;
783 log_warning_unit(UNIT(s)->id,
784 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
787 if (s->tcp_congestion)
788 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
789 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
791 #ifdef HAVE_ATTR_XATTR_H
793 if (fsetxattr(fd, "security.SMACK64IPIN", s->smack_ip_in, strlen(s->smack_ip_in), 0) < 0)
794 log_error_unit(UNIT(s)->id,
795 "fsetxattr(\"security.SMACK64IPIN\"): %m");
798 if (fsetxattr(fd, "security.SMACK64IPOUT", s->smack_ip_out, strlen(s->smack_ip_out), 0) < 0)
799 log_error_unit(UNIT(s)->id,
800 "fsetxattr(\"security.SMACK64IPOUT\"): %m");
804 static void socket_apply_fifo_options(Socket *s, int fd) {
808 if (s->pipe_size > 0)
809 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
810 log_warning_unit(UNIT(s)->id,
813 #ifdef HAVE_ATTR_XATTR_H
815 if (fsetxattr(fd, "security.SMACK64", s->smack, strlen(s->smack), 0) < 0)
816 log_error_unit(UNIT(s)->id,
817 "fsetxattr(\"security.SMACK64\"): %m");
821 static int fifo_address_create(
823 mode_t directory_mode,
834 mkdir_parents_label(path, directory_mode);
836 r = label_context_set(path, S_IFIFO);
840 /* Enforce the right access mode for the fifo */
841 old_mask = umask(~ socket_mode);
843 /* Include the original umask in our mask */
844 umask(~socket_mode | old_mask);
846 r = mkfifo(path, socket_mode);
849 if (r < 0 && errno != EEXIST) {
854 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
859 label_context_clear();
861 if (fstat(fd, &st) < 0) {
866 if (!S_ISFIFO(st.st_mode) ||
867 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
868 st.st_uid != getuid() ||
869 st.st_gid != getgid()) {
879 label_context_clear();
882 close_nointr_nofail(fd);
887 static int special_address_create(
897 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
902 if (fstat(fd, &st) < 0) {
907 /* Check whether this is a /proc, /sys or /dev file or char device */
908 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
918 close_nointr_nofail(fd);
923 static int mq_address_create(
933 struct mq_attr _attr, *attr = NULL;
938 if (maxmsg > 0 && msgsize > 0) {
940 _attr.mq_flags = O_NONBLOCK;
941 _attr.mq_maxmsg = maxmsg;
942 _attr.mq_msgsize = msgsize;
946 /* Enforce the right access mode for the mq */
947 old_mask = umask(~ mq_mode);
949 /* Include the original umask in our mask */
950 umask(~mq_mode | old_mask);
952 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
960 if (fstat(fd, &st) < 0) {
965 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
966 st.st_uid != getuid() ||
967 st.st_gid != getgid()) {
978 close_nointr_nofail(fd);
983 static int socket_open_fds(Socket *s) {
987 bool know_label = false;
991 LIST_FOREACH(port, p, s->ports) {
996 if (p->type == SOCKET_SOCKET) {
1000 if ((r = socket_instantiate_service(s)) < 0)
1003 if (UNIT_DEREF(s->service) &&
1004 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1005 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1016 if ((r = socket_address_listen(
1029 socket_apply_socket_options(s, p->fd);
1031 } else if (p->type == SOCKET_SPECIAL) {
1033 if ((r = special_address_create(
1038 } else if (p->type == SOCKET_FIFO) {
1040 if ((r = fifo_address_create(
1047 socket_apply_fifo_options(s, p->fd);
1048 } else if (p->type == SOCKET_MQUEUE) {
1050 if ((r = mq_address_create(
1058 assert_not_reached("Unknown port type");
1065 socket_close_fds(s);
1070 static void socket_unwatch_fds(Socket *s) {
1075 LIST_FOREACH(port, p, s->ports) {
1079 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1083 static int socket_watch_fds(Socket *s) {
1089 LIST_FOREACH(port, p, s->ports) {
1093 p->fd_watch.socket_accept =
1095 p->type == SOCKET_SOCKET &&
1096 socket_address_can_accept(&p->address);
1098 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1105 socket_unwatch_fds(s);
1109 static void socket_set_state(Socket *s, SocketState state) {
1110 SocketState old_state;
1113 old_state = s->state;
1116 if (state != SOCKET_START_PRE &&
1117 state != SOCKET_START_POST &&
1118 state != SOCKET_STOP_PRE &&
1119 state != SOCKET_STOP_PRE_SIGTERM &&
1120 state != SOCKET_STOP_PRE_SIGKILL &&
1121 state != SOCKET_STOP_POST &&
1122 state != SOCKET_FINAL_SIGTERM &&
1123 state != SOCKET_FINAL_SIGKILL) {
1124 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1125 socket_unwatch_control_pid(s);
1126 s->control_command = NULL;
1127 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1130 if (state != SOCKET_LISTENING)
1131 socket_unwatch_fds(s);
1133 if (state != SOCKET_START_POST &&
1134 state != SOCKET_LISTENING &&
1135 state != SOCKET_RUNNING &&
1136 state != SOCKET_STOP_PRE &&
1137 state != SOCKET_STOP_PRE_SIGTERM &&
1138 state != SOCKET_STOP_PRE_SIGKILL)
1139 socket_close_fds(s);
1141 if (state != old_state)
1142 log_debug_unit(UNIT(s)->id,
1143 "%s changed %s -> %s", UNIT(s)->id,
1144 socket_state_to_string(old_state),
1145 socket_state_to_string(state));
1147 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1150 static int socket_coldplug(Unit *u) {
1151 Socket *s = SOCKET(u);
1155 assert(s->state == SOCKET_DEAD);
1157 if (s->deserialized_state != s->state) {
1159 if (s->deserialized_state == SOCKET_START_PRE ||
1160 s->deserialized_state == SOCKET_START_POST ||
1161 s->deserialized_state == SOCKET_STOP_PRE ||
1162 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1163 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1164 s->deserialized_state == SOCKET_STOP_POST ||
1165 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1166 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1168 if (s->control_pid <= 0)
1171 r = unit_watch_pid(UNIT(s), s->control_pid);
1175 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1180 if (s->deserialized_state == SOCKET_START_POST ||
1181 s->deserialized_state == SOCKET_LISTENING ||
1182 s->deserialized_state == SOCKET_RUNNING ||
1183 s->deserialized_state == SOCKET_STOP_PRE ||
1184 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1185 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1186 if ((r = socket_open_fds(s)) < 0)
1189 if (s->deserialized_state == SOCKET_LISTENING)
1190 if ((r = socket_watch_fds(s)) < 0)
1193 socket_set_state(s, s->deserialized_state);
1199 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1208 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1212 argv = unit_full_printf_strv(UNIT(s), c->argv);
1222 UNIT(s)->manager->environment,
1226 UNIT(s)->manager->confirm_spawn,
1227 UNIT(s)->cgroup_bondings,
1228 UNIT(s)->cgroup_attributes,
1238 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1239 /* FIXME: we need to do something here */
1247 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1252 static void socket_enter_dead(Socket *s, SocketResult f) {
1255 if (f != SOCKET_SUCCESS)
1258 exec_context_tmp_dirs_done(&s->exec_context);
1259 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1262 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1264 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1268 if (f != SOCKET_SUCCESS)
1271 socket_unwatch_control_pid(s);
1273 s->control_command_id = SOCKET_EXEC_STOP_POST;
1275 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1276 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1279 socket_set_state(s, SOCKET_STOP_POST);
1281 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1286 log_warning_unit(UNIT(s)->id,
1287 "%s failed to run 'stop-post' task: %s",
1288 UNIT(s)->id, strerror(-r));
1289 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1292 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1297 if (f != SOCKET_SUCCESS)
1300 r = unit_kill_context(
1303 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1311 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1315 socket_set_state(s, state);
1316 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1317 socket_enter_stop_post(s, SOCKET_SUCCESS);
1319 socket_enter_dead(s, SOCKET_SUCCESS);
1324 log_warning_unit(UNIT(s)->id,
1325 "%s failed to kill processes: %s",
1326 UNIT(s)->id, strerror(-r));
1328 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1329 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1331 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1334 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1338 if (f != SOCKET_SUCCESS)
1341 socket_unwatch_control_pid(s);
1343 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1345 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1346 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1349 socket_set_state(s, SOCKET_STOP_PRE);
1351 socket_enter_stop_post(s, SOCKET_SUCCESS);
1356 log_warning_unit(UNIT(s)->id,
1357 "%s failed to run 'stop-pre' task: %s",
1358 UNIT(s)->id, strerror(-r));
1359 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1362 static void socket_enter_listening(Socket *s) {
1366 r = socket_watch_fds(s);
1368 log_warning_unit(UNIT(s)->id,
1369 "%s failed to watch sockets: %s",
1370 UNIT(s)->id, strerror(-r));
1374 socket_set_state(s, SOCKET_LISTENING);
1378 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1381 static void socket_enter_start_post(Socket *s) {
1385 r = socket_open_fds(s);
1387 log_warning_unit(UNIT(s)->id,
1388 "%s failed to listen on sockets: %s",
1389 UNIT(s)->id, strerror(-r));
1393 socket_unwatch_control_pid(s);
1395 s->control_command_id = SOCKET_EXEC_START_POST;
1397 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1398 r = socket_spawn(s, s->control_command, &s->control_pid);
1400 log_warning_unit(UNIT(s)->id,
1401 "%s failed to run 'start-post' task: %s",
1402 UNIT(s)->id, strerror(-r));
1406 socket_set_state(s, SOCKET_START_POST);
1408 socket_enter_listening(s);
1413 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1416 static void socket_enter_start_pre(Socket *s) {
1420 socket_unwatch_control_pid(s);
1422 s->control_command_id = SOCKET_EXEC_START_PRE;
1424 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1425 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1428 socket_set_state(s, SOCKET_START_PRE);
1430 socket_enter_start_post(s);
1435 log_warning_unit(UNIT(s)->id,
1436 "%s failed to run 'start-pre' task: %s",
1437 UNIT(s)->id, strerror(-r));
1438 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1441 static void socket_enter_running(Socket *s, int cfd) {
1446 dbus_error_init(&error);
1448 /* We don't take connections anymore if we are supposed to
1449 * shut down anyway */
1450 if (unit_pending_inactive(UNIT(s))) {
1451 log_debug_unit(UNIT(s)->id,
1452 "Suppressing connection request on %s since unit stop is scheduled.",
1456 close_nointr_nofail(cfd);
1458 /* Flush all sockets by closing and reopening them */
1459 socket_close_fds(s);
1461 r = socket_watch_fds(s);
1463 log_warning_unit(UNIT(s)->id,
1464 "%s failed to watch sockets: %s",
1465 UNIT(s)->id, strerror(-r));
1466 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1476 bool pending = false;
1478 /* If there's already a start pending don't bother to
1480 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1481 if (unit_pending_active(u)) {
1487 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1492 socket_set_state(s, SOCKET_RUNNING);
1494 char *prefix, *instance = NULL, *name;
1497 if (s->n_connections >= s->max_connections) {
1498 log_warning_unit(UNIT(s)->id,
1499 "%s: Too many incoming connections (%u)",
1500 UNIT(s)->id, s->n_connections);
1501 close_nointr_nofail(cfd);
1505 r = socket_instantiate_service(s);
1509 r = instance_from_socket(cfd, s->n_accepted, &instance);
1514 /* ENOTCONN is legitimate if TCP RST was received.
1515 * This connection is over, but the socket unit lives on. */
1516 close_nointr_nofail(cfd);
1520 prefix = unit_name_to_prefix(UNIT(s)->id);
1527 name = unit_name_build(prefix, instance, ".service");
1536 r = unit_add_name(UNIT_DEREF(s->service), name);
1542 service = SERVICE(UNIT_DEREF(s->service));
1543 unit_ref_unset(&s->service);
1546 UNIT(service)->no_gc = false;
1548 unit_choose_id(UNIT(service), name);
1551 r = service_set_socket_fd(service, cfd, s);
1556 s->n_connections ++;
1558 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1562 /* Notify clients about changed counters */
1563 unit_add_to_dbus_queue(UNIT(s));
1569 log_warning_unit(UNIT(s)->id,
1570 "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1572 cfd >= 0 ? "template" : "non-template",
1573 bus_error(&error, r));
1574 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1577 close_nointr_nofail(cfd);
1579 dbus_error_free(&error);
1582 static void socket_run_next(Socket *s) {
1586 assert(s->control_command);
1587 assert(s->control_command->command_next);
1589 socket_unwatch_control_pid(s);
1591 s->control_command = s->control_command->command_next;
1593 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1599 log_warning_unit(UNIT(s)->id,
1600 "%s failed to run next task: %s",
1601 UNIT(s)->id, strerror(-r));
1603 if (s->state == SOCKET_START_POST)
1604 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1605 else if (s->state == SOCKET_STOP_POST)
1606 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1608 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1611 static int socket_start(Unit *u) {
1612 Socket *s = SOCKET(u);
1616 /* We cannot fulfill this request right now, try again later
1618 if (s->state == SOCKET_STOP_PRE ||
1619 s->state == SOCKET_STOP_PRE_SIGKILL ||
1620 s->state == SOCKET_STOP_PRE_SIGTERM ||
1621 s->state == SOCKET_STOP_POST ||
1622 s->state == SOCKET_FINAL_SIGTERM ||
1623 s->state == SOCKET_FINAL_SIGKILL)
1626 if (s->state == SOCKET_START_PRE ||
1627 s->state == SOCKET_START_POST)
1630 /* Cannot run this without the service being around */
1631 if (UNIT_DEREF(s->service)) {
1634 service = SERVICE(UNIT_DEREF(s->service));
1636 if (UNIT(service)->load_state != UNIT_LOADED) {
1637 log_error_unit(UNIT(service)->id,
1638 "Socket service %s not loaded, refusing.",
1643 /* If the service is already active we cannot start the
1645 if (service->state != SERVICE_DEAD &&
1646 service->state != SERVICE_FAILED &&
1647 service->state != SERVICE_AUTO_RESTART) {
1648 log_error_unit(UNIT(service)->id,
1649 "Socket service %s already active, refusing.",
1654 #ifdef HAVE_SYSV_COMPAT
1655 if (service->is_sysv) {
1656 log_error_unit(UNIT(s)->id,
1657 "Using SysV services for socket activation is not supported. Refusing.");
1663 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1665 s->result = SOCKET_SUCCESS;
1666 socket_enter_start_pre(s);
1670 static int socket_stop(Unit *u) {
1671 Socket *s = SOCKET(u);
1676 if (s->state == SOCKET_STOP_PRE ||
1677 s->state == SOCKET_STOP_PRE_SIGTERM ||
1678 s->state == SOCKET_STOP_PRE_SIGKILL ||
1679 s->state == SOCKET_STOP_POST ||
1680 s->state == SOCKET_FINAL_SIGTERM ||
1681 s->state == SOCKET_FINAL_SIGKILL)
1684 /* If there's already something running we go directly into
1686 if (s->state == SOCKET_START_PRE ||
1687 s->state == SOCKET_START_POST) {
1688 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1692 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1694 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1698 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1699 Socket *s = SOCKET(u);
1707 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1708 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1709 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1711 if (s->control_pid > 0)
1712 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1714 if (s->control_command_id >= 0)
1715 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1717 LIST_FOREACH(port, p, s->ports) {
1723 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1726 if (p->type == SOCKET_SOCKET) {
1729 r = socket_address_print(&p->address, &t);
1733 if (socket_address_family(&p->address) == AF_NETLINK)
1734 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1736 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1738 } else if (p->type == SOCKET_SPECIAL)
1739 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1740 else if (p->type == SOCKET_MQUEUE)
1741 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1743 assert(p->type == SOCKET_FIFO);
1744 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1748 exec_context_serialize(&s->exec_context, UNIT(s), f);
1753 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1754 Socket *s = SOCKET(u);
1761 if (streq(key, "state")) {
1764 state = socket_state_from_string(value);
1766 log_debug_unit(u->id,
1767 "Failed to parse state value %s", value);
1769 s->deserialized_state = state;
1770 } else if (streq(key, "result")) {
1773 f = socket_result_from_string(value);
1775 log_debug_unit(u->id,
1776 "Failed to parse result value %s", value);
1777 else if (f != SOCKET_SUCCESS)
1780 } else if (streq(key, "n-accepted")) {
1783 if (safe_atou(value, &k) < 0)
1784 log_debug_unit(u->id,
1785 "Failed to parse n-accepted value %s", value);
1788 } else if (streq(key, "control-pid")) {
1791 if (parse_pid(value, &pid) < 0)
1792 log_debug_unit(u->id,
1793 "Failed to parse control-pid value %s", value);
1795 s->control_pid = pid;
1796 } else if (streq(key, "control-command")) {
1797 SocketExecCommand id;
1799 id = socket_exec_command_from_string(value);
1801 log_debug_unit(u->id,
1802 "Failed to parse exec-command value %s", value);
1804 s->control_command_id = id;
1805 s->control_command = s->exec_command[id];
1807 } else if (streq(key, "fifo")) {
1811 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1812 log_debug_unit(u->id,
1813 "Failed to parse fifo value %s", value);
1816 LIST_FOREACH(port, p, s->ports)
1817 if (p->type == SOCKET_FIFO &&
1818 streq_ptr(p->path, value+skip))
1823 close_nointr_nofail(p->fd);
1824 p->fd = fdset_remove(fds, fd);
1828 } else if (streq(key, "special")) {
1832 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1833 log_debug_unit(u->id,
1834 "Failed to parse special value %s", value);
1837 LIST_FOREACH(port, p, s->ports)
1838 if (p->type == SOCKET_SPECIAL &&
1839 streq_ptr(p->path, value+skip))
1844 close_nointr_nofail(p->fd);
1845 p->fd = fdset_remove(fds, fd);
1849 } else if (streq(key, "mqueue")) {
1853 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1854 log_debug_unit(u->id,
1855 "Failed to parse mqueue value %s", value);
1858 LIST_FOREACH(port, p, s->ports)
1859 if (p->type == SOCKET_MQUEUE &&
1860 streq_ptr(p->path, value+skip))
1865 close_nointr_nofail(p->fd);
1866 p->fd = fdset_remove(fds, fd);
1870 } else if (streq(key, "socket")) {
1871 int fd, type, skip = 0;
1874 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1875 log_debug_unit(u->id,
1876 "Failed to parse socket value %s", value);
1879 LIST_FOREACH(port, p, s->ports)
1880 if (socket_address_is(&p->address, value+skip, type))
1885 close_nointr_nofail(p->fd);
1886 p->fd = fdset_remove(fds, fd);
1890 } else if (streq(key, "netlink")) {
1894 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1895 log_debug_unit(u->id,
1896 "Failed to parse socket value %s", value);
1899 LIST_FOREACH(port, p, s->ports)
1900 if (socket_address_is_netlink(&p->address, value+skip))
1905 close_nointr_nofail(p->fd);
1906 p->fd = fdset_remove(fds, fd);
1909 } else if (streq(key, "tmp-dir")) {
1916 s->exec_context.tmp_dir = t;
1917 } else if (streq(key, "var-tmp-dir")) {
1924 s->exec_context.var_tmp_dir = t;
1926 log_debug_unit(UNIT(s)->id,
1927 "Unknown serialization key '%s'", key);
1932 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1933 Socket *s = SOCKET(u);
1938 LIST_FOREACH(port, p, s->ports) {
1942 if (p->type != SOCKET_SOCKET)
1948 FDSET_FOREACH(fd, fds, i) {
1949 if (socket_address_matches_fd(&p->address, fd)) {
1950 p->fd = fdset_remove(fds, fd);
1951 s->deserialized_state = SOCKET_LISTENING;
1960 static UnitActiveState socket_active_state(Unit *u) {
1963 return state_translation_table[SOCKET(u)->state];
1966 static const char *socket_sub_state_to_string(Unit *u) {
1969 return socket_state_to_string(SOCKET(u)->state);
1972 static bool socket_check_gc(Unit *u) {
1973 Socket *s = SOCKET(u);
1977 return s->n_connections > 0;
1980 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1981 Socket *s = SOCKET(u);
1987 if (s->state != SOCKET_LISTENING)
1990 log_debug_unit(u->id, "Incoming traffic on %s", u->id);
1992 if (events != EPOLLIN) {
1994 if (events & EPOLLHUP)
1995 log_error_unit(u->id,
1996 "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
1999 log_error_unit(u->id,
2000 "%s: Got unexpected poll event (0x%x) on socket.",
2006 if (w->socket_accept) {
2009 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2015 log_error_unit(u->id,
2016 "Failed to accept socket: %m");
2023 socket_apply_socket_options(s, cfd);
2026 socket_enter_running(s, cfd);
2030 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2033 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2034 Socket *s = SOCKET(u);
2040 if (pid != s->control_pid)
2045 if (is_clean_exit(code, status, NULL))
2047 else if (code == CLD_EXITED)
2048 f = SOCKET_FAILURE_EXIT_CODE;
2049 else if (code == CLD_KILLED)
2050 f = SOCKET_FAILURE_SIGNAL;
2051 else if (code == CLD_DUMPED)
2052 f = SOCKET_FAILURE_CORE_DUMP;
2054 assert_not_reached("Unknown code");
2056 if (s->control_command) {
2057 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2059 if (s->control_command->ignore)
2063 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2065 "%s control process exited, code=%s status=%i",
2066 u->id, sigchld_code_to_string(code), status);
2068 if (f != SOCKET_SUCCESS)
2071 if (s->control_command &&
2072 s->control_command->command_next &&
2073 f == SOCKET_SUCCESS) {
2075 log_debug_unit(u->id,
2076 "%s running next command for state %s",
2077 u->id, socket_state_to_string(s->state));
2080 s->control_command = NULL;
2081 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2083 /* No further commands for this step, so let's figure
2084 * out what to do next */
2086 log_debug_unit(u->id,
2087 "%s got final SIGCHLD for state %s",
2088 u->id, socket_state_to_string(s->state));
2092 case SOCKET_START_PRE:
2093 if (f == SOCKET_SUCCESS)
2094 socket_enter_start_post(s);
2096 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2099 case SOCKET_START_POST:
2100 if (f == SOCKET_SUCCESS)
2101 socket_enter_listening(s);
2103 socket_enter_stop_pre(s, f);
2106 case SOCKET_STOP_PRE:
2107 case SOCKET_STOP_PRE_SIGTERM:
2108 case SOCKET_STOP_PRE_SIGKILL:
2109 socket_enter_stop_post(s, f);
2112 case SOCKET_STOP_POST:
2113 case SOCKET_FINAL_SIGTERM:
2114 case SOCKET_FINAL_SIGKILL:
2115 socket_enter_dead(s, f);
2119 assert_not_reached("Uh, control process died at wrong time.");
2123 /* Notify clients about changed exit status */
2124 unit_add_to_dbus_queue(u);
2127 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2128 Socket *s = SOCKET(u);
2131 assert(elapsed == 1);
2132 assert(w == &s->timer_watch);
2136 case SOCKET_START_PRE:
2137 log_warning_unit(u->id,
2138 "%s starting timed out. Terminating.", u->id);
2139 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2142 case SOCKET_START_POST:
2143 log_warning_unit(u->id,
2144 "%s starting timed out. Stopping.", u->id);
2145 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2148 case SOCKET_STOP_PRE:
2149 log_warning_unit(u->id,
2150 "%s stopping timed out. Terminating.", u->id);
2151 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2154 case SOCKET_STOP_PRE_SIGTERM:
2155 if (s->kill_context.send_sigkill) {
2156 log_warning_unit(u->id,
2157 "%s stopping timed out. Killing.", u->id);
2158 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2160 log_warning_unit(u->id,
2161 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2163 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2167 case SOCKET_STOP_PRE_SIGKILL:
2168 log_warning_unit(u->id,
2169 "%s still around after SIGKILL. Ignoring.", u->id);
2170 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2173 case SOCKET_STOP_POST:
2174 log_warning_unit(u->id,
2175 "%s stopping timed out (2). Terminating.", u->id);
2176 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2179 case SOCKET_FINAL_SIGTERM:
2180 if (s->kill_context.send_sigkill) {
2181 log_warning_unit(u->id,
2182 "%s stopping timed out (2). Killing.", u->id);
2183 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2185 log_warning_unit(u->id,
2186 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2188 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2192 case SOCKET_FINAL_SIGKILL:
2193 log_warning_unit(u->id,
2194 "%s still around after SIGKILL (2). Entering failed mode.",
2196 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2200 assert_not_reached("Timeout at wrong time.");
2204 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2213 /* Called from the service code for requesting our fds */
2216 LIST_FOREACH(port, p, s->ports)
2226 if (!(rfds = new(int, rn_fds)))
2230 LIST_FOREACH(port, p, s->ports)
2234 assert(k == rn_fds);
2242 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2245 /* The service is dead. Dang!
2247 * This is strictly for one-instance-for-all-connections
2250 if (s->state == SOCKET_RUNNING) {
2251 log_debug_unit(UNIT(s)->id,
2252 "%s got notified about service death (failed permanently: %s)",
2253 UNIT(s)->id, yes_no(failed_permanent));
2254 if (failed_permanent)
2255 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2257 socket_enter_listening(s);
2261 void socket_connection_unref(Socket *s) {
2264 /* The service is dead. Yay!
2266 * This is strictly for one-instance-per-connection
2269 assert(s->n_connections > 0);
2272 log_debug_unit(UNIT(s)->id,
2273 "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2276 static void socket_reset_failed(Unit *u) {
2277 Socket *s = SOCKET(u);
2281 if (s->state == SOCKET_FAILED)
2282 socket_set_state(s, SOCKET_DEAD);
2284 s->result = SOCKET_SUCCESS;
2287 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2288 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2291 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2292 [SOCKET_DEAD] = "dead",
2293 [SOCKET_START_PRE] = "start-pre",
2294 [SOCKET_START_POST] = "start-post",
2295 [SOCKET_LISTENING] = "listening",
2296 [SOCKET_RUNNING] = "running",
2297 [SOCKET_STOP_PRE] = "stop-pre",
2298 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2299 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2300 [SOCKET_STOP_POST] = "stop-post",
2301 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2302 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2303 [SOCKET_FAILED] = "failed"
2306 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2308 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2309 [SOCKET_EXEC_START_PRE] = "StartPre",
2310 [SOCKET_EXEC_START_POST] = "StartPost",
2311 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2312 [SOCKET_EXEC_STOP_POST] = "StopPost"
2315 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2317 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2318 [SOCKET_SUCCESS] = "success",
2319 [SOCKET_FAILURE_RESOURCES] = "resources",
2320 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2321 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2322 [SOCKET_FAILURE_SIGNAL] = "signal",
2323 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2324 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2327 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2329 const UnitVTable socket_vtable = {
2330 .object_size = sizeof(Socket),
2337 .exec_context_offset = offsetof(Socket, exec_context),
2338 .exec_section = "Socket",
2340 .init = socket_init,
2341 .done = socket_done,
2342 .load = socket_load,
2344 .kill = socket_kill,
2346 .coldplug = socket_coldplug,
2348 .dump = socket_dump,
2350 .start = socket_start,
2351 .stop = socket_stop,
2353 .serialize = socket_serialize,
2354 .deserialize_item = socket_deserialize_item,
2355 .distribute_fds = socket_distribute_fds,
2357 .active_state = socket_active_state,
2358 .sub_state_to_string = socket_sub_state_to_string,
2360 .check_gc = socket_check_gc,
2362 .fd_event = socket_fd_event,
2363 .sigchld_event = socket_sigchld_event,
2364 .timer_event = socket_timer_event,
2366 .reset_failed = socket_reset_failed,
2368 .bus_interface = "org.freedesktop.systemd1.Socket",
2369 .bus_message_handler = bus_socket_message_handler,
2370 .bus_invalidating_properties = bus_socket_invalidating_properties,
2372 .status_message_formats = {
2373 /*.starting_stopping = {
2374 [0] = "Starting socket %s...",
2375 [1] = "Stopping socket %s...",
2377 .finished_start_job = {
2378 [JOB_DONE] = "Listening on %s.",
2379 [JOB_FAILED] = "Failed to listen on %s.",
2380 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2381 [JOB_TIMEOUT] = "Timed out starting %s.",
2383 .finished_stop_job = {
2384 [JOB_DONE] = "Closed %s.",
2385 [JOB_FAILED] = "Failed stopping %s.",
2386 [JOB_TIMEOUT] = "Timed out stopping %s.",