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 = DEFAULT_TIMEOUT_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)))
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 if ((r = socket_address_listen(
1009 socket_apply_socket_options(s, p->fd);
1011 } else if (p->type == SOCKET_SPECIAL) {
1013 if ((r = special_address_create(
1018 } else if (p->type == SOCKET_FIFO) {
1020 if ((r = fifo_address_create(
1027 socket_apply_fifo_options(s, p->fd);
1028 } else if (p->type == SOCKET_MQUEUE) {
1030 if ((r = mq_address_create(
1038 assert_not_reached("Unknown port type");
1045 socket_close_fds(s);
1050 static void socket_unwatch_fds(Socket *s) {
1055 LIST_FOREACH(port, p, s->ports) {
1059 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1063 static int socket_watch_fds(Socket *s) {
1069 LIST_FOREACH(port, p, s->ports) {
1073 p->fd_watch.socket_accept =
1075 p->type == SOCKET_SOCKET &&
1076 socket_address_can_accept(&p->address);
1078 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1085 socket_unwatch_fds(s);
1089 static void socket_set_state(Socket *s, SocketState state) {
1090 SocketState old_state;
1093 old_state = s->state;
1096 if (state != SOCKET_START_PRE &&
1097 state != SOCKET_START_POST &&
1098 state != SOCKET_STOP_PRE &&
1099 state != SOCKET_STOP_PRE_SIGTERM &&
1100 state != SOCKET_STOP_PRE_SIGKILL &&
1101 state != SOCKET_STOP_POST &&
1102 state != SOCKET_FINAL_SIGTERM &&
1103 state != SOCKET_FINAL_SIGKILL) {
1104 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1105 socket_unwatch_control_pid(s);
1106 s->control_command = NULL;
1107 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1110 if (state != SOCKET_LISTENING)
1111 socket_unwatch_fds(s);
1113 if (state != SOCKET_START_POST &&
1114 state != SOCKET_LISTENING &&
1115 state != SOCKET_RUNNING &&
1116 state != SOCKET_STOP_PRE &&
1117 state != SOCKET_STOP_PRE_SIGTERM &&
1118 state != SOCKET_STOP_PRE_SIGKILL)
1119 socket_close_fds(s);
1121 if (state != old_state)
1122 log_debug_unit(UNIT(s)->id,
1123 "%s changed %s -> %s", UNIT(s)->id,
1124 socket_state_to_string(old_state),
1125 socket_state_to_string(state));
1127 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1130 static int socket_coldplug(Unit *u) {
1131 Socket *s = SOCKET(u);
1135 assert(s->state == SOCKET_DEAD);
1137 if (s->deserialized_state != s->state) {
1139 if (s->deserialized_state == SOCKET_START_PRE ||
1140 s->deserialized_state == SOCKET_START_POST ||
1141 s->deserialized_state == SOCKET_STOP_PRE ||
1142 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1143 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1144 s->deserialized_state == SOCKET_STOP_POST ||
1145 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1146 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1148 if (s->control_pid <= 0)
1151 r = unit_watch_pid(UNIT(s), s->control_pid);
1155 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1160 if (s->deserialized_state == SOCKET_START_POST ||
1161 s->deserialized_state == SOCKET_LISTENING ||
1162 s->deserialized_state == SOCKET_RUNNING ||
1163 s->deserialized_state == SOCKET_STOP_PRE ||
1164 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1165 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1166 if ((r = socket_open_fds(s)) < 0)
1169 if (s->deserialized_state == SOCKET_LISTENING)
1170 if ((r = socket_watch_fds(s)) < 0)
1173 socket_set_state(s, s->deserialized_state);
1179 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1188 unit_realize_cgroup(UNIT(s));
1190 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1194 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1202 UNIT(s)->manager->environment,
1206 UNIT(s)->manager->confirm_spawn,
1207 UNIT(s)->manager->cgroup_supported,
1208 UNIT(s)->cgroup_path,
1217 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1218 /* FIXME: we need to do something here */
1226 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1231 static void socket_enter_dead(Socket *s, SocketResult f) {
1234 if (f != SOCKET_SUCCESS)
1237 exec_context_tmp_dirs_done(&s->exec_context);
1238 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1241 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1243 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1247 if (f != SOCKET_SUCCESS)
1250 socket_unwatch_control_pid(s);
1252 s->control_command_id = SOCKET_EXEC_STOP_POST;
1254 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1255 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1258 socket_set_state(s, SOCKET_STOP_POST);
1260 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1265 log_warning_unit(UNIT(s)->id,
1266 "%s failed to run 'stop-post' task: %s",
1267 UNIT(s)->id, strerror(-r));
1268 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1271 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1276 if (f != SOCKET_SUCCESS)
1279 r = unit_kill_context(
1282 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1290 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1294 socket_set_state(s, state);
1295 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1296 socket_enter_stop_post(s, SOCKET_SUCCESS);
1298 socket_enter_dead(s, SOCKET_SUCCESS);
1303 log_warning_unit(UNIT(s)->id,
1304 "%s failed to kill processes: %s",
1305 UNIT(s)->id, strerror(-r));
1307 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1308 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1310 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1313 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1317 if (f != SOCKET_SUCCESS)
1320 socket_unwatch_control_pid(s);
1322 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1324 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1325 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1328 socket_set_state(s, SOCKET_STOP_PRE);
1330 socket_enter_stop_post(s, SOCKET_SUCCESS);
1335 log_warning_unit(UNIT(s)->id,
1336 "%s failed to run 'stop-pre' task: %s",
1337 UNIT(s)->id, strerror(-r));
1338 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1341 static void socket_enter_listening(Socket *s) {
1345 r = socket_watch_fds(s);
1347 log_warning_unit(UNIT(s)->id,
1348 "%s failed to watch sockets: %s",
1349 UNIT(s)->id, strerror(-r));
1353 socket_set_state(s, SOCKET_LISTENING);
1357 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1360 static void socket_enter_start_post(Socket *s) {
1364 r = socket_open_fds(s);
1366 log_warning_unit(UNIT(s)->id,
1367 "%s failed to listen on sockets: %s",
1368 UNIT(s)->id, strerror(-r));
1372 socket_unwatch_control_pid(s);
1374 s->control_command_id = SOCKET_EXEC_START_POST;
1376 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1377 r = socket_spawn(s, s->control_command, &s->control_pid);
1379 log_warning_unit(UNIT(s)->id,
1380 "%s failed to run 'start-post' task: %s",
1381 UNIT(s)->id, strerror(-r));
1385 socket_set_state(s, SOCKET_START_POST);
1387 socket_enter_listening(s);
1392 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1395 static void socket_enter_start_pre(Socket *s) {
1399 socket_unwatch_control_pid(s);
1401 s->control_command_id = SOCKET_EXEC_START_PRE;
1403 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1404 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1407 socket_set_state(s, SOCKET_START_PRE);
1409 socket_enter_start_post(s);
1414 log_warning_unit(UNIT(s)->id,
1415 "%s failed to run 'start-pre' task: %s",
1416 UNIT(s)->id, strerror(-r));
1417 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1420 static void socket_enter_running(Socket *s, int cfd) {
1425 dbus_error_init(&error);
1427 /* We don't take connections anymore if we are supposed to
1428 * shut down anyway */
1429 if (unit_stop_pending(UNIT(s))) {
1430 log_debug_unit(UNIT(s)->id,
1431 "Suppressing connection request on %s since unit stop is scheduled.",
1435 close_nointr_nofail(cfd);
1437 /* Flush all sockets by closing and reopening them */
1438 socket_close_fds(s);
1440 r = socket_watch_fds(s);
1442 log_warning_unit(UNIT(s)->id,
1443 "%s failed to watch sockets: %s",
1444 UNIT(s)->id, strerror(-r));
1445 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1455 bool pending = false;
1457 /* If there's already a start pending don't bother to
1459 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1460 if (unit_active_or_pending(u)) {
1466 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1471 socket_set_state(s, SOCKET_RUNNING);
1473 char *prefix, *instance = NULL, *name;
1476 if (s->n_connections >= s->max_connections) {
1477 log_warning_unit(UNIT(s)->id,
1478 "%s: Too many incoming connections (%u)",
1479 UNIT(s)->id, s->n_connections);
1480 close_nointr_nofail(cfd);
1484 r = socket_instantiate_service(s);
1488 r = instance_from_socket(cfd, s->n_accepted, &instance);
1493 /* ENOTCONN is legitimate if TCP RST was received.
1494 * This connection is over, but the socket unit lives on. */
1495 close_nointr_nofail(cfd);
1499 prefix = unit_name_to_prefix(UNIT(s)->id);
1506 name = unit_name_build(prefix, instance, ".service");
1515 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);
1530 r = service_set_socket_fd(service, cfd, s);
1535 s->n_connections ++;
1537 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1541 /* Notify clients about changed counters */
1542 unit_add_to_dbus_queue(UNIT(s));
1548 log_warning_unit(UNIT(s)->id,
1549 "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1551 cfd >= 0 ? "template" : "non-template",
1552 bus_error(&error, r));
1553 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1556 close_nointr_nofail(cfd);
1558 dbus_error_free(&error);
1561 static void socket_run_next(Socket *s) {
1565 assert(s->control_command);
1566 assert(s->control_command->command_next);
1568 socket_unwatch_control_pid(s);
1570 s->control_command = s->control_command->command_next;
1572 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1578 log_warning_unit(UNIT(s)->id,
1579 "%s failed to run next task: %s",
1580 UNIT(s)->id, strerror(-r));
1582 if (s->state == SOCKET_START_POST)
1583 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1584 else if (s->state == SOCKET_STOP_POST)
1585 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1587 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1590 static int socket_start(Unit *u) {
1591 Socket *s = SOCKET(u);
1595 /* We cannot fulfill this request right now, try again later
1597 if (s->state == SOCKET_STOP_PRE ||
1598 s->state == SOCKET_STOP_PRE_SIGKILL ||
1599 s->state == SOCKET_STOP_PRE_SIGTERM ||
1600 s->state == SOCKET_STOP_POST ||
1601 s->state == SOCKET_FINAL_SIGTERM ||
1602 s->state == SOCKET_FINAL_SIGKILL)
1605 if (s->state == SOCKET_START_PRE ||
1606 s->state == SOCKET_START_POST)
1609 /* Cannot run this without the service being around */
1610 if (UNIT_ISSET(s->service)) {
1613 service = SERVICE(UNIT_DEREF(s->service));
1615 if (UNIT(service)->load_state != UNIT_LOADED) {
1616 log_error_unit(u->id,
1617 "Socket service %s not loaded, refusing.",
1622 /* If the service is already active we cannot start the
1624 if (service->state != SERVICE_DEAD &&
1625 service->state != SERVICE_FAILED &&
1626 service->state != SERVICE_AUTO_RESTART) {
1627 log_error_unit(u->id,
1628 "Socket service %s already active, refusing.",
1633 #ifdef HAVE_SYSV_COMPAT
1634 if (service->is_sysv) {
1635 log_error_unit(u->id,
1636 "Using SysV services for socket activation is not supported. Refusing.");
1642 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1644 s->result = SOCKET_SUCCESS;
1645 socket_enter_start_pre(s);
1649 static int socket_stop(Unit *u) {
1650 Socket *s = SOCKET(u);
1655 if (s->state == SOCKET_STOP_PRE ||
1656 s->state == SOCKET_STOP_PRE_SIGTERM ||
1657 s->state == SOCKET_STOP_PRE_SIGKILL ||
1658 s->state == SOCKET_STOP_POST ||
1659 s->state == SOCKET_FINAL_SIGTERM ||
1660 s->state == SOCKET_FINAL_SIGKILL)
1663 /* If there's already something running we go directly into
1665 if (s->state == SOCKET_START_PRE ||
1666 s->state == SOCKET_START_POST) {
1667 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1671 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1673 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1677 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1678 Socket *s = SOCKET(u);
1686 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1687 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1688 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1690 if (s->control_pid > 0)
1691 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1693 if (s->control_command_id >= 0)
1694 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1696 LIST_FOREACH(port, p, s->ports) {
1702 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1705 if (p->type == SOCKET_SOCKET) {
1708 r = socket_address_print(&p->address, &t);
1712 if (socket_address_family(&p->address) == AF_NETLINK)
1713 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1715 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1717 } else if (p->type == SOCKET_SPECIAL)
1718 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1719 else if (p->type == SOCKET_MQUEUE)
1720 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1722 assert(p->type == SOCKET_FIFO);
1723 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1727 exec_context_serialize(&s->exec_context, UNIT(s), f);
1732 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1733 Socket *s = SOCKET(u);
1740 if (streq(key, "state")) {
1743 state = socket_state_from_string(value);
1745 log_debug_unit(u->id,
1746 "Failed to parse state value %s", value);
1748 s->deserialized_state = state;
1749 } else if (streq(key, "result")) {
1752 f = socket_result_from_string(value);
1754 log_debug_unit(u->id,
1755 "Failed to parse result value %s", value);
1756 else if (f != SOCKET_SUCCESS)
1759 } else if (streq(key, "n-accepted")) {
1762 if (safe_atou(value, &k) < 0)
1763 log_debug_unit(u->id,
1764 "Failed to parse n-accepted value %s", value);
1767 } else if (streq(key, "control-pid")) {
1770 if (parse_pid(value, &pid) < 0)
1771 log_debug_unit(u->id,
1772 "Failed to parse control-pid value %s", value);
1774 s->control_pid = pid;
1775 } else if (streq(key, "control-command")) {
1776 SocketExecCommand id;
1778 id = socket_exec_command_from_string(value);
1780 log_debug_unit(u->id,
1781 "Failed to parse exec-command value %s", value);
1783 s->control_command_id = id;
1784 s->control_command = s->exec_command[id];
1786 } else if (streq(key, "fifo")) {
1790 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1791 log_debug_unit(u->id,
1792 "Failed to parse fifo value %s", value);
1795 LIST_FOREACH(port, p, s->ports)
1796 if (p->type == SOCKET_FIFO &&
1797 streq_ptr(p->path, value+skip))
1802 close_nointr_nofail(p->fd);
1803 p->fd = fdset_remove(fds, fd);
1807 } else if (streq(key, "special")) {
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 special value %s", value);
1816 LIST_FOREACH(port, p, s->ports)
1817 if (p->type == SOCKET_SPECIAL &&
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, "mqueue")) {
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 mqueue value %s", value);
1837 LIST_FOREACH(port, p, s->ports)
1838 if (p->type == SOCKET_MQUEUE &&
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, "socket")) {
1850 int fd, type, skip = 0;
1853 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1854 log_debug_unit(u->id,
1855 "Failed to parse socket value %s", value);
1858 LIST_FOREACH(port, p, s->ports)
1859 if (socket_address_is(&p->address, value+skip, type))
1864 close_nointr_nofail(p->fd);
1865 p->fd = fdset_remove(fds, fd);
1869 } else if (streq(key, "netlink")) {
1873 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1874 log_debug_unit(u->id,
1875 "Failed to parse socket value %s", value);
1878 LIST_FOREACH(port, p, s->ports)
1879 if (socket_address_is_netlink(&p->address, value+skip))
1884 close_nointr_nofail(p->fd);
1885 p->fd = fdset_remove(fds, fd);
1888 } else if (streq(key, "tmp-dir")) {
1895 s->exec_context.tmp_dir = t;
1896 } else if (streq(key, "var-tmp-dir")) {
1903 s->exec_context.var_tmp_dir = t;
1905 log_debug_unit(UNIT(s)->id,
1906 "Unknown serialization key '%s'", key);
1911 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1912 Socket *s = SOCKET(u);
1917 LIST_FOREACH(port, p, s->ports) {
1921 if (p->type != SOCKET_SOCKET)
1927 FDSET_FOREACH(fd, fds, i) {
1928 if (socket_address_matches_fd(&p->address, fd)) {
1929 p->fd = fdset_remove(fds, fd);
1930 s->deserialized_state = SOCKET_LISTENING;
1939 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1942 return state_translation_table[SOCKET(u)->state];
1945 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1948 return socket_state_to_string(SOCKET(u)->state);
1951 const char* socket_port_type_to_string(SocketPort *p) {
1957 switch (p->address.type) {
1958 case SOCK_STREAM: return "Stream";
1959 case SOCK_DGRAM: return "Datagram";
1960 case SOCK_SEQPACKET: return "SequentialPacket";
1962 if (socket_address_family(&p->address) == AF_NETLINK)
1964 default: return "Invalid";
1966 case SOCKET_SPECIAL: return "Special";
1967 case SOCKET_MQUEUE: return "MessageQueue";
1968 case SOCKET_FIFO: return "FIFO";
1969 default: return NULL;
1973 _pure_ static bool socket_check_gc(Unit *u) {
1974 Socket *s = SOCKET(u);
1978 return s->n_connections > 0;
1981 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1982 Socket *s = SOCKET(u);
1988 if (s->state != SOCKET_LISTENING)
1991 log_debug_unit(u->id, "Incoming traffic on %s", u->id);
1993 if (events != EPOLLIN) {
1995 if (events & EPOLLHUP)
1996 log_error_unit(u->id,
1997 "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
2000 log_error_unit(u->id,
2001 "%s: Got unexpected poll event (0x%x) on socket.",
2007 if (w->socket_accept) {
2010 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2016 log_error_unit(u->id,
2017 "Failed to accept socket: %m");
2024 socket_apply_socket_options(s, cfd);
2027 socket_enter_running(s, cfd);
2031 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2034 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2035 Socket *s = SOCKET(u);
2041 if (pid != s->control_pid)
2046 if (is_clean_exit(code, status, NULL))
2048 else if (code == CLD_EXITED)
2049 f = SOCKET_FAILURE_EXIT_CODE;
2050 else if (code == CLD_KILLED)
2051 f = SOCKET_FAILURE_SIGNAL;
2052 else if (code == CLD_DUMPED)
2053 f = SOCKET_FAILURE_CORE_DUMP;
2055 assert_not_reached("Unknown code");
2057 if (s->control_command) {
2058 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2060 if (s->control_command->ignore)
2064 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2066 "%s control process exited, code=%s status=%i",
2067 u->id, sigchld_code_to_string(code), status);
2069 if (f != SOCKET_SUCCESS)
2072 if (s->control_command &&
2073 s->control_command->command_next &&
2074 f == SOCKET_SUCCESS) {
2076 log_debug_unit(u->id,
2077 "%s running next command for state %s",
2078 u->id, socket_state_to_string(s->state));
2081 s->control_command = NULL;
2082 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2084 /* No further commands for this step, so let's figure
2085 * out what to do next */
2087 log_debug_unit(u->id,
2088 "%s got final SIGCHLD for state %s",
2089 u->id, socket_state_to_string(s->state));
2093 case SOCKET_START_PRE:
2094 if (f == SOCKET_SUCCESS)
2095 socket_enter_start_post(s);
2097 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2100 case SOCKET_START_POST:
2101 if (f == SOCKET_SUCCESS)
2102 socket_enter_listening(s);
2104 socket_enter_stop_pre(s, f);
2107 case SOCKET_STOP_PRE:
2108 case SOCKET_STOP_PRE_SIGTERM:
2109 case SOCKET_STOP_PRE_SIGKILL:
2110 socket_enter_stop_post(s, f);
2113 case SOCKET_STOP_POST:
2114 case SOCKET_FINAL_SIGTERM:
2115 case SOCKET_FINAL_SIGKILL:
2116 socket_enter_dead(s, f);
2120 assert_not_reached("Uh, control process died at wrong time.");
2124 /* Notify clients about changed exit status */
2125 unit_add_to_dbus_queue(u);
2128 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2129 Socket *s = SOCKET(u);
2132 assert(elapsed == 1);
2133 assert(w == &s->timer_watch);
2137 case SOCKET_START_PRE:
2138 log_warning_unit(u->id,
2139 "%s starting timed out. Terminating.", u->id);
2140 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2143 case SOCKET_START_POST:
2144 log_warning_unit(u->id,
2145 "%s starting timed out. Stopping.", u->id);
2146 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2149 case SOCKET_STOP_PRE:
2150 log_warning_unit(u->id,
2151 "%s stopping timed out. Terminating.", u->id);
2152 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2155 case SOCKET_STOP_PRE_SIGTERM:
2156 if (s->kill_context.send_sigkill) {
2157 log_warning_unit(u->id,
2158 "%s stopping timed out. Killing.", u->id);
2159 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2161 log_warning_unit(u->id,
2162 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2164 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2168 case SOCKET_STOP_PRE_SIGKILL:
2169 log_warning_unit(u->id,
2170 "%s still around after SIGKILL. Ignoring.", u->id);
2171 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2174 case SOCKET_STOP_POST:
2175 log_warning_unit(u->id,
2176 "%s stopping timed out (2). Terminating.", u->id);
2177 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2180 case SOCKET_FINAL_SIGTERM:
2181 if (s->kill_context.send_sigkill) {
2182 log_warning_unit(u->id,
2183 "%s stopping timed out (2). Killing.", u->id);
2184 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2186 log_warning_unit(u->id,
2187 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2189 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2193 case SOCKET_FINAL_SIGKILL:
2194 log_warning_unit(u->id,
2195 "%s still around after SIGKILL (2). Entering failed mode.",
2197 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2201 assert_not_reached("Timeout at wrong time.");
2205 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2214 /* Called from the service code for requesting our fds */
2217 LIST_FOREACH(port, p, s->ports)
2227 if (!(rfds = new(int, rn_fds)))
2231 LIST_FOREACH(port, p, s->ports)
2235 assert(k == rn_fds);
2243 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2246 /* The service is dead. Dang!
2248 * This is strictly for one-instance-for-all-connections
2251 if (s->state == SOCKET_RUNNING) {
2252 log_debug_unit(UNIT(s)->id,
2253 "%s got notified about service death (failed permanently: %s)",
2254 UNIT(s)->id, yes_no(failed_permanent));
2255 if (failed_permanent)
2256 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2258 socket_enter_listening(s);
2262 void socket_connection_unref(Socket *s) {
2265 /* The service is dead. Yay!
2267 * This is strictly for one-instance-per-connection
2270 assert(s->n_connections > 0);
2273 log_debug_unit(UNIT(s)->id,
2274 "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2277 static void socket_reset_failed(Unit *u) {
2278 Socket *s = SOCKET(u);
2282 if (s->state == SOCKET_FAILED)
2283 socket_set_state(s, SOCKET_DEAD);
2285 s->result = SOCKET_SUCCESS;
2288 static void socket_trigger_notify(Unit *u, Unit *other) {
2289 Socket *s = SOCKET(u);
2290 Service *se = SERVICE(other);
2295 /* Don't propagate state changes from the service if we are
2296 already down or accepting connections */
2297 if ((s->state != SOCKET_RUNNING &&
2298 s->state != SOCKET_LISTENING) ||
2302 if (other->load_state != UNIT_LOADED ||
2303 other->type != UNIT_SERVICE)
2306 if (se->state == SERVICE_FAILED)
2307 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2309 if (se->state == SERVICE_DEAD ||
2310 se->state == SERVICE_STOP ||
2311 se->state == SERVICE_STOP_SIGTERM ||
2312 se->state == SERVICE_STOP_SIGKILL ||
2313 se->state == SERVICE_STOP_POST ||
2314 se->state == SERVICE_FINAL_SIGTERM ||
2315 se->state == SERVICE_FINAL_SIGKILL ||
2316 se->state == SERVICE_AUTO_RESTART)
2317 socket_notify_service_dead(s, false);
2319 if (se->state == SERVICE_RUNNING)
2320 socket_set_state(s, SOCKET_RUNNING);
2323 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2324 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2327 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2328 [SOCKET_DEAD] = "dead",
2329 [SOCKET_START_PRE] = "start-pre",
2330 [SOCKET_START_POST] = "start-post",
2331 [SOCKET_LISTENING] = "listening",
2332 [SOCKET_RUNNING] = "running",
2333 [SOCKET_STOP_PRE] = "stop-pre",
2334 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2335 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2336 [SOCKET_STOP_POST] = "stop-post",
2337 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2338 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2339 [SOCKET_FAILED] = "failed"
2342 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2344 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2345 [SOCKET_EXEC_START_PRE] = "StartPre",
2346 [SOCKET_EXEC_START_POST] = "StartPost",
2347 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2348 [SOCKET_EXEC_STOP_POST] = "StopPost"
2351 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2353 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2354 [SOCKET_SUCCESS] = "success",
2355 [SOCKET_FAILURE_RESOURCES] = "resources",
2356 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2357 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2358 [SOCKET_FAILURE_SIGNAL] = "signal",
2359 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2360 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2363 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2365 const UnitVTable socket_vtable = {
2366 .object_size = sizeof(Socket),
2373 .private_section = "Socket",
2374 .exec_context_offset = offsetof(Socket, exec_context),
2375 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2377 .init = socket_init,
2378 .done = socket_done,
2379 .load = socket_load,
2381 .kill = socket_kill,
2383 .coldplug = socket_coldplug,
2385 .dump = socket_dump,
2387 .start = socket_start,
2388 .stop = socket_stop,
2390 .serialize = socket_serialize,
2391 .deserialize_item = socket_deserialize_item,
2392 .distribute_fds = socket_distribute_fds,
2394 .active_state = socket_active_state,
2395 .sub_state_to_string = socket_sub_state_to_string,
2397 .check_gc = socket_check_gc,
2399 .fd_event = socket_fd_event,
2400 .sigchld_event = socket_sigchld_event,
2401 .timer_event = socket_timer_event,
2403 .trigger_notify = socket_trigger_notify,
2405 .reset_failed = socket_reset_failed,
2407 .bus_interface = "org.freedesktop.systemd1.Socket",
2408 .bus_message_handler = bus_socket_message_handler,
2409 .bus_invalidating_properties = bus_socket_invalidating_properties,
2410 .bus_set_property = bus_socket_set_property,
2411 .bus_commit_properties = bus_socket_commit_properties,
2413 .status_message_formats = {
2414 /*.starting_stopping = {
2415 [0] = "Starting socket %s...",
2416 [1] = "Stopping socket %s...",
2418 .finished_start_job = {
2419 [JOB_DONE] = "Listening on %s.",
2420 [JOB_FAILED] = "Failed to listen on %s.",
2421 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2422 [JOB_TIMEOUT] = "Timed out starting %s.",
2424 .finished_stop_job = {
2425 [JOB_DONE] = "Closed %s.",
2426 [JOB_FAILED] = "Failed stopping %s.",
2427 [JOB_TIMEOUT] = "Timed out stopping %s.",