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>
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 "dbus-common.h"
51 #include "exit-status.h"
53 #include "smack-util.h"
55 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
56 [SOCKET_DEAD] = UNIT_INACTIVE,
57 [SOCKET_START_PRE] = UNIT_ACTIVATING,
58 [SOCKET_START_POST] = UNIT_ACTIVATING,
59 [SOCKET_LISTENING] = UNIT_ACTIVE,
60 [SOCKET_RUNNING] = UNIT_ACTIVE,
61 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
62 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
63 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
64 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
65 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
66 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
67 [SOCKET_FAILED] = UNIT_FAILED
70 static void socket_init(Unit *u) {
71 Socket *s = SOCKET(u);
74 assert(u->load_state == UNIT_STUB);
76 s->backlog = SOMAXCONN;
77 s->timeout_usec = u->manager->default_timeout_start_usec;
78 s->directory_mode = 0755;
79 s->socket_mode = 0666;
81 s->max_connections = 64;
88 exec_context_init(&s->exec_context);
89 s->exec_context.std_output = u->manager->default_std_output;
90 s->exec_context.std_error = u->manager->default_std_error;
91 kill_context_init(&s->kill_context);
92 cgroup_context_init(&s->cgroup_context);
94 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
97 static void socket_unwatch_control_pid(Socket *s) {
100 if (s->control_pid <= 0)
103 unit_unwatch_pid(UNIT(s), s->control_pid);
107 void socket_free_ports(Socket *s) {
112 while ((p = s->ports)) {
113 LIST_REMOVE(port, s->ports, p);
116 unit_unwatch_fd(UNIT(s), &p->fd_watch);
117 close_nointr_nofail(p->fd);
125 static void socket_done(Unit *u) {
126 Socket *s = SOCKET(u);
130 socket_free_ports(s);
132 exec_context_done(&s->exec_context, manager_is_reloading_or_reexecuting(u->manager));
133 cgroup_context_init(&s->cgroup_context);
135 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
136 s->control_command = NULL;
138 socket_unwatch_control_pid(s);
140 unit_ref_unset(&s->service);
142 free(s->tcp_congestion);
143 s->tcp_congestion = NULL;
145 free(s->bind_to_device);
146 s->bind_to_device = NULL;
149 free(s->smack_ip_in);
150 free(s->smack_ip_out);
152 unit_unwatch_timer(u, &s->timer_watch);
155 static int socket_instantiate_service(Socket *s) {
162 /* This fills in s->service if it isn't filled in yet. For
163 * Accept=yes sockets we create the next connection service
164 * here. For Accept=no this is mostly a NOP since the service
165 * is figured out at load time anyway. */
167 if (UNIT_DEREF(s->service))
172 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
175 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
181 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
187 #ifdef HAVE_SYSV_COMPAT
188 if (SERVICE(u)->is_sysv) {
189 log_error("Using SysV services for socket activation is not supported. Refusing.");
195 unit_ref_set(&s->service, u);
197 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
200 static bool have_non_accept_socket(Socket *s) {
208 LIST_FOREACH(port, p, s->ports) {
210 if (p->type != SOCKET_SOCKET)
213 if (!socket_address_can_accept(&p->address))
220 static int socket_verify(Socket *s) {
223 if (UNIT(s)->load_state != UNIT_LOADED)
227 log_error_unit(UNIT(s)->id,
228 "%s lacks Listen setting. Refusing.", UNIT(s)->id);
232 if (s->accept && have_non_accept_socket(s)) {
233 log_error_unit(UNIT(s)->id,
234 "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
239 if (s->accept && s->max_connections <= 0) {
240 log_error_unit(UNIT(s)->id,
241 "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
245 if (s->accept && UNIT_DEREF(s->service)) {
246 log_error_unit(UNIT(s)->id,
247 "Explicit service configuration for accepting sockets not supported on %s. Refusing.",
252 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
253 log_error_unit(UNIT(s)->id,
254 "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.",
262 static int socket_add_mount_links(Socket *s) {
268 LIST_FOREACH(port, p, s->ports) {
269 const char *path = NULL;
271 if (p->type == SOCKET_SOCKET)
272 path = socket_address_get_path(&p->address);
273 else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL)
279 r = unit_require_mounts_for(UNIT(s), path);
287 static int socket_add_device_link(Socket *s) {
293 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
296 if (asprintf(&t, "/sys/subsystem/net/devices/%s", s->bind_to_device) < 0)
299 r = unit_add_node_link(UNIT(s), t, false);
305 static int socket_add_default_dependencies(Socket *s) {
309 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
313 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
314 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
319 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
322 _pure_ static bool socket_has_exec(Socket *s) {
326 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
327 if (s->exec_command[i])
333 static int socket_load(Unit *u) {
334 Socket *s = SOCKET(u);
338 assert(u->load_state == UNIT_STUB);
340 if ((r = unit_load_fragment_and_dropin(u)) < 0)
343 /* This is a new unit? Then let's add in some extras */
344 if (u->load_state == UNIT_LOADED) {
346 if (have_non_accept_socket(s)) {
348 if (!UNIT_DEREF(s->service)) {
351 r = unit_load_related_unit(u, ".service", &x);
355 unit_ref_set(&s->service, x);
358 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
363 if ((r = socket_add_mount_links(s)) < 0)
366 if ((r = socket_add_device_link(s)) < 0)
369 if (socket_has_exec(s))
370 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
373 r = unit_add_default_slice(u);
377 if (UNIT(s)->default_dependencies)
378 if ((r = socket_add_default_dependencies(s)) < 0)
381 r = unit_exec_context_defaults(u, &s->exec_context);
386 return socket_verify(s);
389 _const_ static const char* listen_lookup(int family, int type) {
391 if (family == AF_NETLINK)
392 return "ListenNetlink";
394 if (type == SOCK_STREAM)
395 return "ListenStream";
396 else if (type == SOCK_DGRAM)
397 return "ListenDatagram";
398 else if (type == SOCK_SEQPACKET)
399 return "ListenSequentialPacket";
401 assert_not_reached("Unknown socket type");
405 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
408 Socket *s = SOCKET(u);
416 p2 = strappend(prefix, "\t");
417 prefix2 = p2 ? p2 : prefix;
420 "%sSocket State: %s\n"
422 "%sBindIPv6Only: %s\n"
424 "%sSocketMode: %04o\n"
425 "%sDirectoryMode: %04o\n"
428 "%sTransparent: %s\n"
430 "%sPassCredentials: %s\n"
431 "%sPassSecurity: %s\n"
432 "%sTCPCongestion: %s\n",
433 prefix, socket_state_to_string(s->state),
434 prefix, socket_result_to_string(s->result),
435 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
437 prefix, s->socket_mode,
438 prefix, s->directory_mode,
439 prefix, yes_no(s->keep_alive),
440 prefix, yes_no(s->free_bind),
441 prefix, yes_no(s->transparent),
442 prefix, yes_no(s->broadcast),
443 prefix, yes_no(s->pass_cred),
444 prefix, yes_no(s->pass_sec),
445 prefix, strna(s->tcp_congestion));
447 if (s->control_pid > 0)
449 "%sControl PID: %lu\n",
450 prefix, (unsigned long) s->control_pid);
452 if (s->bind_to_device)
454 "%sBindToDevice: %s\n",
455 prefix, s->bind_to_device);
460 "%sNConnections: %u\n"
461 "%sMaxConnections: %u\n",
462 prefix, s->n_accepted,
463 prefix, s->n_connections,
464 prefix, s->max_connections);
466 if (s->priority >= 0)
469 prefix, s->priority);
471 if (s->receive_buffer > 0)
473 "%sReceiveBuffer: %zu\n",
474 prefix, s->receive_buffer);
476 if (s->send_buffer > 0)
478 "%sSendBuffer: %zu\n",
479 prefix, s->send_buffer);
491 if (s->pipe_size > 0)
494 prefix, s->pipe_size);
501 if (s->mq_maxmsg > 0)
503 "%sMessageQueueMaxMessages: %li\n",
504 prefix, s->mq_maxmsg);
506 if (s->mq_msgsize > 0)
508 "%sMessageQueueMessageSize: %li\n",
509 prefix, s->mq_msgsize);
514 prefix, yes_no(s->reuseport));
518 "%sSmackLabel: %s\n",
523 "%sSmackLabelIPIn: %s\n",
524 prefix, s->smack_ip_in);
528 "%sSmackLabelIPOut: %s\n",
529 prefix, s->smack_ip_out);
531 LIST_FOREACH(port, p, s->ports) {
533 if (p->type == SOCKET_SOCKET) {
538 if ((r = socket_address_print(&p->address, &k)) < 0)
543 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
545 } else if (p->type == SOCKET_SPECIAL)
546 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
547 else if (p->type == SOCKET_MQUEUE)
548 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
550 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
553 exec_context_dump(&s->exec_context, f, prefix);
554 kill_context_dump(&s->kill_context, f, prefix);
556 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
557 if (!s->exec_command[c])
560 fprintf(f, "%s-> %s:\n",
561 prefix, socket_exec_command_to_string(c));
563 exec_command_dump_list(s->exec_command[c], f, prefix2);
569 static int instance_from_socket(int fd, unsigned nr, char **instance) {
574 struct sockaddr_un un;
575 struct sockaddr_in in;
576 struct sockaddr_in6 in6;
577 struct sockaddr_storage storage;
584 if (getsockname(fd, &local.sa, &l) < 0)
588 if (getpeername(fd, &remote.sa, &l) < 0)
591 switch (local.sa.sa_family) {
595 a = ntohl(local.in.sin_addr.s_addr),
596 b = ntohl(remote.in.sin_addr.s_addr);
599 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
601 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
602 ntohs(local.in.sin_port),
603 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
604 ntohs(remote.in.sin_port)) < 0)
611 static const unsigned char ipv4_prefix[] = {
612 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
615 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
616 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
618 *a = local.in6.sin6_addr.s6_addr+12,
619 *b = remote.in6.sin6_addr.s6_addr+12;
622 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
624 a[0], a[1], a[2], a[3],
625 ntohs(local.in6.sin6_port),
626 b[0], b[1], b[2], b[3],
627 ntohs(remote.in6.sin6_port)) < 0)
630 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
635 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
636 ntohs(local.in6.sin6_port),
637 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
638 ntohs(remote.in6.sin6_port)) < 0)
649 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
655 (unsigned long) ucred.pid,
656 (unsigned long) ucred.uid) < 0)
663 assert_not_reached("Unhandled socket type.");
670 static void socket_close_fds(Socket *s) {
675 LIST_FOREACH(port, p, s->ports) {
679 unit_unwatch_fd(UNIT(s), &p->fd_watch);
680 close_nointr_nofail(p->fd);
682 /* One little note: we should never delete any sockets
683 * in the file system here! After all some other
684 * process we spawned might still have a reference of
685 * this fd and wants to continue to use it. Therefore
686 * we delete sockets in the file system before we
687 * create a new one, not after we stopped using
694 static void socket_apply_socket_options(Socket *s, int fd) {
699 int b = s->keep_alive;
700 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
701 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
706 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
707 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
712 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
713 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
718 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
719 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
722 if (s->priority >= 0)
723 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
724 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
726 if (s->receive_buffer > 0) {
727 int value = (int) s->receive_buffer;
729 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
731 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
732 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
733 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
736 if (s->send_buffer > 0) {
737 int value = (int) s->send_buffer;
738 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
739 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
740 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
744 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
745 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
748 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
749 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
751 if (s->ip_ttl >= 0) {
754 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
756 if (socket_ipv6_is_supported())
757 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
760 errno = EAFNOSUPPORT;
764 log_warning_unit(UNIT(s)->id,
765 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
768 if (s->tcp_congestion)
769 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
770 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
773 int b = s->reuseport;
774 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)) < 0)
775 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
779 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
780 log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
783 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
784 log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
787 static void socket_apply_fifo_options(Socket *s, int fd) {
791 if (s->pipe_size > 0)
792 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
793 log_warning_unit(UNIT(s)->id,
797 if (smack_label_fd(fd, s->smack) < 0)
798 log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
801 static int fifo_address_create(
803 mode_t directory_mode,
814 mkdir_parents_label(path, directory_mode);
816 r = label_context_set(path, S_IFIFO);
820 /* Enforce the right access mode for the fifo */
821 old_mask = umask(~ socket_mode);
823 /* Include the original umask in our mask */
824 umask(~socket_mode | old_mask);
826 r = mkfifo(path, socket_mode);
829 if (r < 0 && errno != EEXIST) {
834 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
839 label_context_clear();
841 if (fstat(fd, &st) < 0) {
846 if (!S_ISFIFO(st.st_mode) ||
847 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
848 st.st_uid != getuid() ||
849 st.st_gid != getgid()) {
859 label_context_clear();
862 close_nointr_nofail(fd);
867 static int special_address_create(
877 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
882 if (fstat(fd, &st) < 0) {
887 /* Check whether this is a /proc, /sys or /dev file or char device */
888 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
898 close_nointr_nofail(fd);
903 static int mq_address_create(
913 struct mq_attr _attr, *attr = NULL;
918 if (maxmsg > 0 && msgsize > 0) {
920 _attr.mq_flags = O_NONBLOCK;
921 _attr.mq_maxmsg = maxmsg;
922 _attr.mq_msgsize = msgsize;
926 /* Enforce the right access mode for the mq */
927 old_mask = umask(~ mq_mode);
929 /* Include the original umask in our mask */
930 umask(~mq_mode | old_mask);
932 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
940 if (fstat(fd, &st) < 0) {
945 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
946 st.st_uid != getuid() ||
947 st.st_gid != getgid()) {
958 close_nointr_nofail(fd);
963 static int socket_open_fds(Socket *s) {
967 bool know_label = false;
971 LIST_FOREACH(port, p, s->ports) {
976 if (p->type == SOCKET_SOCKET) {
980 if ((r = socket_instantiate_service(s)) < 0)
983 if (UNIT_ISSET(s->service) &&
984 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
985 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
996 r = socket_address_listen(
998 SOCK_CLOEXEC|SOCK_NONBLOCK,
1011 socket_apply_socket_options(s, p->fd);
1013 } else if (p->type == SOCKET_SPECIAL) {
1015 r = special_address_create(
1021 } else if (p->type == SOCKET_FIFO) {
1023 r = fifo_address_create(
1031 socket_apply_fifo_options(s, p->fd);
1032 } else if (p->type == SOCKET_MQUEUE) {
1034 r = mq_address_create(
1043 assert_not_reached("Unknown port type");
1050 socket_close_fds(s);
1055 static void socket_unwatch_fds(Socket *s) {
1060 LIST_FOREACH(port, p, s->ports) {
1064 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1068 static int socket_watch_fds(Socket *s) {
1074 LIST_FOREACH(port, p, s->ports) {
1078 p->fd_watch.socket_accept =
1080 p->type == SOCKET_SOCKET &&
1081 socket_address_can_accept(&p->address);
1083 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1090 socket_unwatch_fds(s);
1094 static void socket_set_state(Socket *s, SocketState state) {
1095 SocketState old_state;
1098 old_state = s->state;
1101 if (state != SOCKET_START_PRE &&
1102 state != SOCKET_START_POST &&
1103 state != SOCKET_STOP_PRE &&
1104 state != SOCKET_STOP_PRE_SIGTERM &&
1105 state != SOCKET_STOP_PRE_SIGKILL &&
1106 state != SOCKET_STOP_POST &&
1107 state != SOCKET_FINAL_SIGTERM &&
1108 state != SOCKET_FINAL_SIGKILL) {
1109 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1110 socket_unwatch_control_pid(s);
1111 s->control_command = NULL;
1112 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1115 if (state != SOCKET_LISTENING)
1116 socket_unwatch_fds(s);
1118 if (state != SOCKET_START_POST &&
1119 state != SOCKET_LISTENING &&
1120 state != SOCKET_RUNNING &&
1121 state != SOCKET_STOP_PRE &&
1122 state != SOCKET_STOP_PRE_SIGTERM &&
1123 state != SOCKET_STOP_PRE_SIGKILL)
1124 socket_close_fds(s);
1126 if (state != old_state)
1127 log_debug_unit(UNIT(s)->id,
1128 "%s changed %s -> %s", UNIT(s)->id,
1129 socket_state_to_string(old_state),
1130 socket_state_to_string(state));
1132 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1135 static int socket_coldplug(Unit *u) {
1136 Socket *s = SOCKET(u);
1140 assert(s->state == SOCKET_DEAD);
1142 if (s->deserialized_state != s->state) {
1144 if (s->deserialized_state == SOCKET_START_PRE ||
1145 s->deserialized_state == SOCKET_START_POST ||
1146 s->deserialized_state == SOCKET_STOP_PRE ||
1147 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1148 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1149 s->deserialized_state == SOCKET_STOP_POST ||
1150 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1151 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1153 if (s->control_pid <= 0)
1156 r = unit_watch_pid(UNIT(s), s->control_pid);
1160 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1165 if (s->deserialized_state == SOCKET_START_POST ||
1166 s->deserialized_state == SOCKET_LISTENING ||
1167 s->deserialized_state == SOCKET_RUNNING ||
1168 s->deserialized_state == SOCKET_STOP_PRE ||
1169 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1170 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1171 if ((r = socket_open_fds(s)) < 0)
1174 if (s->deserialized_state == SOCKET_LISTENING)
1175 if ((r = socket_watch_fds(s)) < 0)
1178 socket_set_state(s, s->deserialized_state);
1184 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1193 unit_realize_cgroup(UNIT(s));
1195 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1199 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1207 UNIT(s)->manager->environment,
1211 UNIT(s)->manager->confirm_spawn,
1212 UNIT(s)->manager->cgroup_supported,
1213 UNIT(s)->cgroup_path,
1222 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1223 /* FIXME: we need to do something here */
1231 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1236 static void socket_enter_dead(Socket *s, SocketResult f) {
1239 if (f != SOCKET_SUCCESS)
1242 exec_context_tmp_dirs_done(&s->exec_context);
1243 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1246 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1248 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1252 if (f != SOCKET_SUCCESS)
1255 socket_unwatch_control_pid(s);
1257 s->control_command_id = SOCKET_EXEC_STOP_POST;
1259 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1260 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1263 socket_set_state(s, SOCKET_STOP_POST);
1265 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1270 log_warning_unit(UNIT(s)->id,
1271 "%s failed to run 'stop-post' task: %s",
1272 UNIT(s)->id, strerror(-r));
1273 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1276 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1281 if (f != SOCKET_SUCCESS)
1284 r = unit_kill_context(
1287 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1295 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1299 socket_set_state(s, state);
1300 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1301 socket_enter_stop_post(s, SOCKET_SUCCESS);
1303 socket_enter_dead(s, SOCKET_SUCCESS);
1308 log_warning_unit(UNIT(s)->id,
1309 "%s failed to kill processes: %s",
1310 UNIT(s)->id, strerror(-r));
1312 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1313 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1315 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1318 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1322 if (f != SOCKET_SUCCESS)
1325 socket_unwatch_control_pid(s);
1327 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1329 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1330 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1333 socket_set_state(s, SOCKET_STOP_PRE);
1335 socket_enter_stop_post(s, SOCKET_SUCCESS);
1340 log_warning_unit(UNIT(s)->id,
1341 "%s failed to run 'stop-pre' task: %s",
1342 UNIT(s)->id, strerror(-r));
1343 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1346 static void socket_enter_listening(Socket *s) {
1350 r = socket_watch_fds(s);
1352 log_warning_unit(UNIT(s)->id,
1353 "%s failed to watch sockets: %s",
1354 UNIT(s)->id, strerror(-r));
1358 socket_set_state(s, SOCKET_LISTENING);
1362 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1365 static void socket_enter_start_post(Socket *s) {
1369 r = socket_open_fds(s);
1371 log_warning_unit(UNIT(s)->id,
1372 "%s failed to listen on sockets: %s",
1373 UNIT(s)->id, strerror(-r));
1377 socket_unwatch_control_pid(s);
1379 s->control_command_id = SOCKET_EXEC_START_POST;
1381 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1382 r = socket_spawn(s, s->control_command, &s->control_pid);
1384 log_warning_unit(UNIT(s)->id,
1385 "%s failed to run 'start-post' task: %s",
1386 UNIT(s)->id, strerror(-r));
1390 socket_set_state(s, SOCKET_START_POST);
1392 socket_enter_listening(s);
1397 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1400 static void socket_enter_start_pre(Socket *s) {
1404 socket_unwatch_control_pid(s);
1406 s->control_command_id = SOCKET_EXEC_START_PRE;
1408 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1409 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1412 socket_set_state(s, SOCKET_START_PRE);
1414 socket_enter_start_post(s);
1419 log_warning_unit(UNIT(s)->id,
1420 "%s failed to run 'start-pre' task: %s",
1421 UNIT(s)->id, strerror(-r));
1422 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1425 static void socket_enter_running(Socket *s, int cfd) {
1430 dbus_error_init(&error);
1432 /* We don't take connections anymore if we are supposed to
1433 * shut down anyway */
1434 if (unit_stop_pending(UNIT(s))) {
1435 log_debug_unit(UNIT(s)->id,
1436 "Suppressing connection request on %s since unit stop is scheduled.",
1440 close_nointr_nofail(cfd);
1442 /* Flush all sockets by closing and reopening them */
1443 socket_close_fds(s);
1445 r = socket_watch_fds(s);
1447 log_warning_unit(UNIT(s)->id,
1448 "%s failed to watch sockets: %s",
1449 UNIT(s)->id, strerror(-r));
1450 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1460 bool pending = false;
1462 /* If there's already a start pending don't bother to
1464 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1465 if (unit_active_or_pending(u)) {
1471 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1476 socket_set_state(s, SOCKET_RUNNING);
1478 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1481 if (s->n_connections >= s->max_connections) {
1482 log_warning_unit(UNIT(s)->id,
1483 "%s: Too many incoming connections (%u)",
1484 UNIT(s)->id, s->n_connections);
1485 close_nointr_nofail(cfd);
1489 r = socket_instantiate_service(s);
1493 r = instance_from_socket(cfd, s->n_accepted, &instance);
1498 /* ENOTCONN is legitimate if TCP RST was received.
1499 * This connection is over, but the socket unit lives on. */
1500 close_nointr_nofail(cfd);
1504 prefix = unit_name_to_prefix(UNIT(s)->id);
1510 name = unit_name_build(prefix, instance, ".service");
1517 r = unit_add_name(UNIT_DEREF(s->service), name);
1521 service = SERVICE(UNIT_DEREF(s->service));
1522 unit_ref_unset(&s->service);
1525 UNIT(service)->no_gc = false;
1527 unit_choose_id(UNIT(service), name);
1529 r = service_set_socket_fd(service, cfd, s);
1534 s->n_connections ++;
1536 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1540 /* Notify clients about changed counters */
1541 unit_add_to_dbus_queue(UNIT(s));
1547 log_warning_unit(UNIT(s)->id,
1548 "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1550 cfd >= 0 ? "template" : "non-template",
1551 bus_error(&error, r));
1552 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1555 close_nointr_nofail(cfd);
1557 dbus_error_free(&error);
1560 static void socket_run_next(Socket *s) {
1564 assert(s->control_command);
1565 assert(s->control_command->command_next);
1567 socket_unwatch_control_pid(s);
1569 s->control_command = s->control_command->command_next;
1571 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1577 log_warning_unit(UNIT(s)->id,
1578 "%s failed to run next task: %s",
1579 UNIT(s)->id, strerror(-r));
1581 if (s->state == SOCKET_START_POST)
1582 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1583 else if (s->state == SOCKET_STOP_POST)
1584 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1586 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1589 static int socket_start(Unit *u) {
1590 Socket *s = SOCKET(u);
1594 /* We cannot fulfill this request right now, try again later
1596 if (s->state == SOCKET_STOP_PRE ||
1597 s->state == SOCKET_STOP_PRE_SIGKILL ||
1598 s->state == SOCKET_STOP_PRE_SIGTERM ||
1599 s->state == SOCKET_STOP_POST ||
1600 s->state == SOCKET_FINAL_SIGTERM ||
1601 s->state == SOCKET_FINAL_SIGKILL)
1604 if (s->state == SOCKET_START_PRE ||
1605 s->state == SOCKET_START_POST)
1608 /* Cannot run this without the service being around */
1609 if (UNIT_ISSET(s->service)) {
1612 service = SERVICE(UNIT_DEREF(s->service));
1614 if (UNIT(service)->load_state != UNIT_LOADED) {
1615 log_error_unit(u->id,
1616 "Socket service %s not loaded, refusing.",
1621 /* If the service is already active we cannot start the
1623 if (service->state != SERVICE_DEAD &&
1624 service->state != SERVICE_FAILED &&
1625 service->state != SERVICE_AUTO_RESTART) {
1626 log_error_unit(u->id,
1627 "Socket service %s already active, refusing.",
1632 #ifdef HAVE_SYSV_COMPAT
1633 if (service->is_sysv) {
1634 log_error_unit(u->id,
1635 "Using SysV services for socket activation is not supported. Refusing.");
1641 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1643 s->result = SOCKET_SUCCESS;
1644 socket_enter_start_pre(s);
1648 static int socket_stop(Unit *u) {
1649 Socket *s = SOCKET(u);
1654 if (s->state == SOCKET_STOP_PRE ||
1655 s->state == SOCKET_STOP_PRE_SIGTERM ||
1656 s->state == SOCKET_STOP_PRE_SIGKILL ||
1657 s->state == SOCKET_STOP_POST ||
1658 s->state == SOCKET_FINAL_SIGTERM ||
1659 s->state == SOCKET_FINAL_SIGKILL)
1662 /* If there's already something running we go directly into
1664 if (s->state == SOCKET_START_PRE ||
1665 s->state == SOCKET_START_POST) {
1666 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1670 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1672 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1676 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1677 Socket *s = SOCKET(u);
1685 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1686 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1687 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1689 if (s->control_pid > 0)
1690 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1692 if (s->control_command_id >= 0)
1693 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1695 LIST_FOREACH(port, p, s->ports) {
1701 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1704 if (p->type == SOCKET_SOCKET) {
1707 r = socket_address_print(&p->address, &t);
1711 if (socket_address_family(&p->address) == AF_NETLINK)
1712 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1714 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1716 } else if (p->type == SOCKET_SPECIAL)
1717 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1718 else if (p->type == SOCKET_MQUEUE)
1719 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1721 assert(p->type == SOCKET_FIFO);
1722 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1726 exec_context_serialize(&s->exec_context, UNIT(s), f);
1731 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1732 Socket *s = SOCKET(u);
1739 if (streq(key, "state")) {
1742 state = socket_state_from_string(value);
1744 log_debug_unit(u->id,
1745 "Failed to parse state value %s", value);
1747 s->deserialized_state = state;
1748 } else if (streq(key, "result")) {
1751 f = socket_result_from_string(value);
1753 log_debug_unit(u->id,
1754 "Failed to parse result value %s", value);
1755 else if (f != SOCKET_SUCCESS)
1758 } else if (streq(key, "n-accepted")) {
1761 if (safe_atou(value, &k) < 0)
1762 log_debug_unit(u->id,
1763 "Failed to parse n-accepted value %s", value);
1766 } else if (streq(key, "control-pid")) {
1769 if (parse_pid(value, &pid) < 0)
1770 log_debug_unit(u->id,
1771 "Failed to parse control-pid value %s", value);
1773 s->control_pid = pid;
1774 } else if (streq(key, "control-command")) {
1775 SocketExecCommand id;
1777 id = socket_exec_command_from_string(value);
1779 log_debug_unit(u->id,
1780 "Failed to parse exec-command value %s", value);
1782 s->control_command_id = id;
1783 s->control_command = s->exec_command[id];
1785 } else if (streq(key, "fifo")) {
1789 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1790 log_debug_unit(u->id,
1791 "Failed to parse fifo value %s", value);
1794 LIST_FOREACH(port, p, s->ports)
1795 if (p->type == SOCKET_FIFO &&
1796 streq_ptr(p->path, value+skip))
1801 close_nointr_nofail(p->fd);
1802 p->fd = fdset_remove(fds, fd);
1806 } else if (streq(key, "special")) {
1810 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1811 log_debug_unit(u->id,
1812 "Failed to parse special value %s", value);
1815 LIST_FOREACH(port, p, s->ports)
1816 if (p->type == SOCKET_SPECIAL &&
1817 streq_ptr(p->path, value+skip))
1822 close_nointr_nofail(p->fd);
1823 p->fd = fdset_remove(fds, fd);
1827 } else if (streq(key, "mqueue")) {
1831 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1832 log_debug_unit(u->id,
1833 "Failed to parse mqueue value %s", value);
1836 LIST_FOREACH(port, p, s->ports)
1837 if (p->type == SOCKET_MQUEUE &&
1838 streq_ptr(p->path, value+skip))
1843 close_nointr_nofail(p->fd);
1844 p->fd = fdset_remove(fds, fd);
1848 } else if (streq(key, "socket")) {
1849 int fd, type, skip = 0;
1852 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1853 log_debug_unit(u->id,
1854 "Failed to parse socket value %s", value);
1857 LIST_FOREACH(port, p, s->ports)
1858 if (socket_address_is(&p->address, value+skip, type))
1863 close_nointr_nofail(p->fd);
1864 p->fd = fdset_remove(fds, fd);
1868 } else if (streq(key, "netlink")) {
1872 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1873 log_debug_unit(u->id,
1874 "Failed to parse socket value %s", value);
1877 LIST_FOREACH(port, p, s->ports)
1878 if (socket_address_is_netlink(&p->address, value+skip))
1883 close_nointr_nofail(p->fd);
1884 p->fd = fdset_remove(fds, fd);
1887 } else if (streq(key, "tmp-dir")) {
1894 s->exec_context.tmp_dir = t;
1895 } else if (streq(key, "var-tmp-dir")) {
1902 s->exec_context.var_tmp_dir = t;
1904 log_debug_unit(UNIT(s)->id,
1905 "Unknown serialization key '%s'", key);
1910 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1911 Socket *s = SOCKET(u);
1916 LIST_FOREACH(port, p, s->ports) {
1920 if (p->type != SOCKET_SOCKET)
1926 FDSET_FOREACH(fd, fds, i) {
1927 if (socket_address_matches_fd(&p->address, fd)) {
1928 p->fd = fdset_remove(fds, fd);
1929 s->deserialized_state = SOCKET_LISTENING;
1938 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1941 return state_translation_table[SOCKET(u)->state];
1944 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1947 return socket_state_to_string(SOCKET(u)->state);
1950 const char* socket_port_type_to_string(SocketPort *p) {
1956 switch (p->address.type) {
1957 case SOCK_STREAM: return "Stream";
1958 case SOCK_DGRAM: return "Datagram";
1959 case SOCK_SEQPACKET: return "SequentialPacket";
1961 if (socket_address_family(&p->address) == AF_NETLINK)
1963 default: return "Invalid";
1965 case SOCKET_SPECIAL: return "Special";
1966 case SOCKET_MQUEUE: return "MessageQueue";
1967 case SOCKET_FIFO: return "FIFO";
1968 default: return NULL;
1972 _pure_ 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 static 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 void socket_trigger_notify(Unit *u, Unit *other) {
2288 Socket *s = SOCKET(u);
2289 Service *se = SERVICE(other);
2294 /* Don't propagate state changes from the service if we are
2295 already down or accepting connections */
2296 if ((s->state != SOCKET_RUNNING &&
2297 s->state != SOCKET_LISTENING) ||
2301 if (other->load_state != UNIT_LOADED ||
2302 other->type != UNIT_SERVICE)
2305 if (se->state == SERVICE_FAILED)
2306 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2308 if (se->state == SERVICE_DEAD ||
2309 se->state == SERVICE_STOP ||
2310 se->state == SERVICE_STOP_SIGTERM ||
2311 se->state == SERVICE_STOP_SIGKILL ||
2312 se->state == SERVICE_STOP_POST ||
2313 se->state == SERVICE_FINAL_SIGTERM ||
2314 se->state == SERVICE_FINAL_SIGKILL ||
2315 se->state == SERVICE_AUTO_RESTART)
2316 socket_notify_service_dead(s, false);
2318 if (se->state == SERVICE_RUNNING)
2319 socket_set_state(s, SOCKET_RUNNING);
2322 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2323 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2326 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2327 [SOCKET_DEAD] = "dead",
2328 [SOCKET_START_PRE] = "start-pre",
2329 [SOCKET_START_POST] = "start-post",
2330 [SOCKET_LISTENING] = "listening",
2331 [SOCKET_RUNNING] = "running",
2332 [SOCKET_STOP_PRE] = "stop-pre",
2333 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2334 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2335 [SOCKET_STOP_POST] = "stop-post",
2336 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2337 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2338 [SOCKET_FAILED] = "failed"
2341 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2343 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2344 [SOCKET_EXEC_START_PRE] = "StartPre",
2345 [SOCKET_EXEC_START_POST] = "StartPost",
2346 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2347 [SOCKET_EXEC_STOP_POST] = "StopPost"
2350 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2352 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2353 [SOCKET_SUCCESS] = "success",
2354 [SOCKET_FAILURE_RESOURCES] = "resources",
2355 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2356 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2357 [SOCKET_FAILURE_SIGNAL] = "signal",
2358 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2359 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2362 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2364 const UnitVTable socket_vtable = {
2365 .object_size = sizeof(Socket),
2372 .private_section = "Socket",
2373 .exec_context_offset = offsetof(Socket, exec_context),
2374 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2376 .init = socket_init,
2377 .done = socket_done,
2378 .load = socket_load,
2380 .kill = socket_kill,
2382 .coldplug = socket_coldplug,
2384 .dump = socket_dump,
2386 .start = socket_start,
2387 .stop = socket_stop,
2389 .serialize = socket_serialize,
2390 .deserialize_item = socket_deserialize_item,
2391 .distribute_fds = socket_distribute_fds,
2393 .active_state = socket_active_state,
2394 .sub_state_to_string = socket_sub_state_to_string,
2396 .check_gc = socket_check_gc,
2398 .fd_event = socket_fd_event,
2399 .sigchld_event = socket_sigchld_event,
2400 .timer_event = socket_timer_event,
2402 .trigger_notify = socket_trigger_notify,
2404 .reset_failed = socket_reset_failed,
2406 .bus_interface = "org.freedesktop.systemd1.Socket",
2407 .bus_message_handler = bus_socket_message_handler,
2408 .bus_invalidating_properties = bus_socket_invalidating_properties,
2409 .bus_set_property = bus_socket_set_property,
2410 .bus_commit_properties = bus_socket_commit_properties,
2412 .status_message_formats = {
2413 /*.starting_stopping = {
2414 [0] = "Starting socket %s...",
2415 [1] = "Stopping socket %s...",
2417 .finished_start_job = {
2418 [JOB_DONE] = "Listening on %s.",
2419 [JOB_FAILED] = "Failed to listen on %s.",
2420 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2421 [JOB_TIMEOUT] = "Timed out starting %s.",
2423 .finished_stop_job = {
2424 [JOB_DONE] = "Closed %s.",
2425 [JOB_FAILED] = "Failed stopping %s.",
2426 [JOB_TIMEOUT] = "Timed out stopping %s.",