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)))
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 char *prefix, *instance = NULL, *name;
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);
1511 name = unit_name_build(prefix, instance, ".service");
1520 r = unit_add_name(UNIT_DEREF(s->service), name);
1526 service = SERVICE(UNIT_DEREF(s->service));
1527 unit_ref_unset(&s->service);
1530 UNIT(service)->no_gc = false;
1532 unit_choose_id(UNIT(service), name);
1535 r = service_set_socket_fd(service, cfd, s);
1540 s->n_connections ++;
1542 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1546 /* Notify clients about changed counters */
1547 unit_add_to_dbus_queue(UNIT(s));
1553 log_warning_unit(UNIT(s)->id,
1554 "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1556 cfd >= 0 ? "template" : "non-template",
1557 bus_error(&error, r));
1558 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1561 close_nointr_nofail(cfd);
1563 dbus_error_free(&error);
1566 static void socket_run_next(Socket *s) {
1570 assert(s->control_command);
1571 assert(s->control_command->command_next);
1573 socket_unwatch_control_pid(s);
1575 s->control_command = s->control_command->command_next;
1577 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1583 log_warning_unit(UNIT(s)->id,
1584 "%s failed to run next task: %s",
1585 UNIT(s)->id, strerror(-r));
1587 if (s->state == SOCKET_START_POST)
1588 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1589 else if (s->state == SOCKET_STOP_POST)
1590 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1592 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1595 static int socket_start(Unit *u) {
1596 Socket *s = SOCKET(u);
1600 /* We cannot fulfill this request right now, try again later
1602 if (s->state == SOCKET_STOP_PRE ||
1603 s->state == SOCKET_STOP_PRE_SIGKILL ||
1604 s->state == SOCKET_STOP_PRE_SIGTERM ||
1605 s->state == SOCKET_STOP_POST ||
1606 s->state == SOCKET_FINAL_SIGTERM ||
1607 s->state == SOCKET_FINAL_SIGKILL)
1610 if (s->state == SOCKET_START_PRE ||
1611 s->state == SOCKET_START_POST)
1614 /* Cannot run this without the service being around */
1615 if (UNIT_ISSET(s->service)) {
1618 service = SERVICE(UNIT_DEREF(s->service));
1620 if (UNIT(service)->load_state != UNIT_LOADED) {
1621 log_error_unit(u->id,
1622 "Socket service %s not loaded, refusing.",
1627 /* If the service is already active we cannot start the
1629 if (service->state != SERVICE_DEAD &&
1630 service->state != SERVICE_FAILED &&
1631 service->state != SERVICE_AUTO_RESTART) {
1632 log_error_unit(u->id,
1633 "Socket service %s already active, refusing.",
1638 #ifdef HAVE_SYSV_COMPAT
1639 if (service->is_sysv) {
1640 log_error_unit(u->id,
1641 "Using SysV services for socket activation is not supported. Refusing.");
1647 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1649 s->result = SOCKET_SUCCESS;
1650 socket_enter_start_pre(s);
1654 static int socket_stop(Unit *u) {
1655 Socket *s = SOCKET(u);
1660 if (s->state == SOCKET_STOP_PRE ||
1661 s->state == SOCKET_STOP_PRE_SIGTERM ||
1662 s->state == SOCKET_STOP_PRE_SIGKILL ||
1663 s->state == SOCKET_STOP_POST ||
1664 s->state == SOCKET_FINAL_SIGTERM ||
1665 s->state == SOCKET_FINAL_SIGKILL)
1668 /* If there's already something running we go directly into
1670 if (s->state == SOCKET_START_PRE ||
1671 s->state == SOCKET_START_POST) {
1672 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1676 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1678 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1682 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1683 Socket *s = SOCKET(u);
1691 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1692 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1693 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1695 if (s->control_pid > 0)
1696 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1698 if (s->control_command_id >= 0)
1699 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1701 LIST_FOREACH(port, p, s->ports) {
1707 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1710 if (p->type == SOCKET_SOCKET) {
1713 r = socket_address_print(&p->address, &t);
1717 if (socket_address_family(&p->address) == AF_NETLINK)
1718 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1720 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1722 } else if (p->type == SOCKET_SPECIAL)
1723 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1724 else if (p->type == SOCKET_MQUEUE)
1725 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1727 assert(p->type == SOCKET_FIFO);
1728 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1732 exec_context_serialize(&s->exec_context, UNIT(s), f);
1737 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1738 Socket *s = SOCKET(u);
1745 if (streq(key, "state")) {
1748 state = socket_state_from_string(value);
1750 log_debug_unit(u->id,
1751 "Failed to parse state value %s", value);
1753 s->deserialized_state = state;
1754 } else if (streq(key, "result")) {
1757 f = socket_result_from_string(value);
1759 log_debug_unit(u->id,
1760 "Failed to parse result value %s", value);
1761 else if (f != SOCKET_SUCCESS)
1764 } else if (streq(key, "n-accepted")) {
1767 if (safe_atou(value, &k) < 0)
1768 log_debug_unit(u->id,
1769 "Failed to parse n-accepted value %s", value);
1772 } else if (streq(key, "control-pid")) {
1775 if (parse_pid(value, &pid) < 0)
1776 log_debug_unit(u->id,
1777 "Failed to parse control-pid value %s", value);
1779 s->control_pid = pid;
1780 } else if (streq(key, "control-command")) {
1781 SocketExecCommand id;
1783 id = socket_exec_command_from_string(value);
1785 log_debug_unit(u->id,
1786 "Failed to parse exec-command value %s", value);
1788 s->control_command_id = id;
1789 s->control_command = s->exec_command[id];
1791 } else if (streq(key, "fifo")) {
1795 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1796 log_debug_unit(u->id,
1797 "Failed to parse fifo value %s", value);
1800 LIST_FOREACH(port, p, s->ports)
1801 if (p->type == SOCKET_FIFO &&
1802 streq_ptr(p->path, value+skip))
1807 close_nointr_nofail(p->fd);
1808 p->fd = fdset_remove(fds, fd);
1812 } else if (streq(key, "special")) {
1816 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1817 log_debug_unit(u->id,
1818 "Failed to parse special value %s", value);
1821 LIST_FOREACH(port, p, s->ports)
1822 if (p->type == SOCKET_SPECIAL &&
1823 streq_ptr(p->path, value+skip))
1828 close_nointr_nofail(p->fd);
1829 p->fd = fdset_remove(fds, fd);
1833 } else if (streq(key, "mqueue")) {
1837 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1838 log_debug_unit(u->id,
1839 "Failed to parse mqueue value %s", value);
1842 LIST_FOREACH(port, p, s->ports)
1843 if (p->type == SOCKET_MQUEUE &&
1844 streq_ptr(p->path, value+skip))
1849 close_nointr_nofail(p->fd);
1850 p->fd = fdset_remove(fds, fd);
1854 } else if (streq(key, "socket")) {
1855 int fd, type, skip = 0;
1858 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1859 log_debug_unit(u->id,
1860 "Failed to parse socket value %s", value);
1863 LIST_FOREACH(port, p, s->ports)
1864 if (socket_address_is(&p->address, value+skip, type))
1869 close_nointr_nofail(p->fd);
1870 p->fd = fdset_remove(fds, fd);
1874 } else if (streq(key, "netlink")) {
1878 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1879 log_debug_unit(u->id,
1880 "Failed to parse socket value %s", value);
1883 LIST_FOREACH(port, p, s->ports)
1884 if (socket_address_is_netlink(&p->address, value+skip))
1889 close_nointr_nofail(p->fd);
1890 p->fd = fdset_remove(fds, fd);
1893 } else if (streq(key, "tmp-dir")) {
1900 s->exec_context.tmp_dir = t;
1901 } else if (streq(key, "var-tmp-dir")) {
1908 s->exec_context.var_tmp_dir = t;
1910 log_debug_unit(UNIT(s)->id,
1911 "Unknown serialization key '%s'", key);
1916 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1917 Socket *s = SOCKET(u);
1922 LIST_FOREACH(port, p, s->ports) {
1926 if (p->type != SOCKET_SOCKET)
1932 FDSET_FOREACH(fd, fds, i) {
1933 if (socket_address_matches_fd(&p->address, fd)) {
1934 p->fd = fdset_remove(fds, fd);
1935 s->deserialized_state = SOCKET_LISTENING;
1944 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1947 return state_translation_table[SOCKET(u)->state];
1950 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1953 return socket_state_to_string(SOCKET(u)->state);
1956 const char* socket_port_type_to_string(SocketPort *p) {
1962 switch (p->address.type) {
1963 case SOCK_STREAM: return "Stream";
1964 case SOCK_DGRAM: return "Datagram";
1965 case SOCK_SEQPACKET: return "SequentialPacket";
1967 if (socket_address_family(&p->address) == AF_NETLINK)
1969 default: return "Invalid";
1971 case SOCKET_SPECIAL: return "Special";
1972 case SOCKET_MQUEUE: return "MessageQueue";
1973 case SOCKET_FIFO: return "FIFO";
1974 default: return NULL;
1978 _pure_ static bool socket_check_gc(Unit *u) {
1979 Socket *s = SOCKET(u);
1983 return s->n_connections > 0;
1986 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1987 Socket *s = SOCKET(u);
1993 if (s->state != SOCKET_LISTENING)
1996 log_debug_unit(u->id, "Incoming traffic on %s", u->id);
1998 if (events != EPOLLIN) {
2000 if (events & EPOLLHUP)
2001 log_error_unit(u->id,
2002 "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
2005 log_error_unit(u->id,
2006 "%s: Got unexpected poll event (0x%x) on socket.",
2012 if (w->socket_accept) {
2015 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2021 log_error_unit(u->id,
2022 "Failed to accept socket: %m");
2029 socket_apply_socket_options(s, cfd);
2032 socket_enter_running(s, cfd);
2036 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2039 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2040 Socket *s = SOCKET(u);
2046 if (pid != s->control_pid)
2051 if (is_clean_exit(code, status, NULL))
2053 else if (code == CLD_EXITED)
2054 f = SOCKET_FAILURE_EXIT_CODE;
2055 else if (code == CLD_KILLED)
2056 f = SOCKET_FAILURE_SIGNAL;
2057 else if (code == CLD_DUMPED)
2058 f = SOCKET_FAILURE_CORE_DUMP;
2060 assert_not_reached("Unknown code");
2062 if (s->control_command) {
2063 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2065 if (s->control_command->ignore)
2069 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2071 "%s control process exited, code=%s status=%i",
2072 u->id, sigchld_code_to_string(code), status);
2074 if (f != SOCKET_SUCCESS)
2077 if (s->control_command &&
2078 s->control_command->command_next &&
2079 f == SOCKET_SUCCESS) {
2081 log_debug_unit(u->id,
2082 "%s running next command for state %s",
2083 u->id, socket_state_to_string(s->state));
2086 s->control_command = NULL;
2087 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2089 /* No further commands for this step, so let's figure
2090 * out what to do next */
2092 log_debug_unit(u->id,
2093 "%s got final SIGCHLD for state %s",
2094 u->id, socket_state_to_string(s->state));
2098 case SOCKET_START_PRE:
2099 if (f == SOCKET_SUCCESS)
2100 socket_enter_start_post(s);
2102 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2105 case SOCKET_START_POST:
2106 if (f == SOCKET_SUCCESS)
2107 socket_enter_listening(s);
2109 socket_enter_stop_pre(s, f);
2112 case SOCKET_STOP_PRE:
2113 case SOCKET_STOP_PRE_SIGTERM:
2114 case SOCKET_STOP_PRE_SIGKILL:
2115 socket_enter_stop_post(s, f);
2118 case SOCKET_STOP_POST:
2119 case SOCKET_FINAL_SIGTERM:
2120 case SOCKET_FINAL_SIGKILL:
2121 socket_enter_dead(s, f);
2125 assert_not_reached("Uh, control process died at wrong time.");
2129 /* Notify clients about changed exit status */
2130 unit_add_to_dbus_queue(u);
2133 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2134 Socket *s = SOCKET(u);
2137 assert(elapsed == 1);
2138 assert(w == &s->timer_watch);
2142 case SOCKET_START_PRE:
2143 log_warning_unit(u->id,
2144 "%s starting timed out. Terminating.", u->id);
2145 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2148 case SOCKET_START_POST:
2149 log_warning_unit(u->id,
2150 "%s starting timed out. Stopping.", u->id);
2151 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2154 case SOCKET_STOP_PRE:
2155 log_warning_unit(u->id,
2156 "%s stopping timed out. Terminating.", u->id);
2157 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2160 case SOCKET_STOP_PRE_SIGTERM:
2161 if (s->kill_context.send_sigkill) {
2162 log_warning_unit(u->id,
2163 "%s stopping timed out. Killing.", u->id);
2164 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2166 log_warning_unit(u->id,
2167 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2169 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2173 case SOCKET_STOP_PRE_SIGKILL:
2174 log_warning_unit(u->id,
2175 "%s still around after SIGKILL. Ignoring.", u->id);
2176 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2179 case SOCKET_STOP_POST:
2180 log_warning_unit(u->id,
2181 "%s stopping timed out (2). Terminating.", u->id);
2182 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2185 case SOCKET_FINAL_SIGTERM:
2186 if (s->kill_context.send_sigkill) {
2187 log_warning_unit(u->id,
2188 "%s stopping timed out (2). Killing.", u->id);
2189 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2191 log_warning_unit(u->id,
2192 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2194 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2198 case SOCKET_FINAL_SIGKILL:
2199 log_warning_unit(u->id,
2200 "%s still around after SIGKILL (2). Entering failed mode.",
2202 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2206 assert_not_reached("Timeout at wrong time.");
2210 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2219 /* Called from the service code for requesting our fds */
2222 LIST_FOREACH(port, p, s->ports)
2232 if (!(rfds = new(int, rn_fds)))
2236 LIST_FOREACH(port, p, s->ports)
2240 assert(k == rn_fds);
2248 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2251 /* The service is dead. Dang!
2253 * This is strictly for one-instance-for-all-connections
2256 if (s->state == SOCKET_RUNNING) {
2257 log_debug_unit(UNIT(s)->id,
2258 "%s got notified about service death (failed permanently: %s)",
2259 UNIT(s)->id, yes_no(failed_permanent));
2260 if (failed_permanent)
2261 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2263 socket_enter_listening(s);
2267 void socket_connection_unref(Socket *s) {
2270 /* The service is dead. Yay!
2272 * This is strictly for one-instance-per-connection
2275 assert(s->n_connections > 0);
2278 log_debug_unit(UNIT(s)->id,
2279 "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2282 static void socket_reset_failed(Unit *u) {
2283 Socket *s = SOCKET(u);
2287 if (s->state == SOCKET_FAILED)
2288 socket_set_state(s, SOCKET_DEAD);
2290 s->result = SOCKET_SUCCESS;
2293 static void socket_trigger_notify(Unit *u, Unit *other) {
2294 Socket *s = SOCKET(u);
2295 Service *se = SERVICE(other);
2300 /* Don't propagate state changes from the service if we are
2301 already down or accepting connections */
2302 if ((s->state != SOCKET_RUNNING &&
2303 s->state != SOCKET_LISTENING) ||
2307 if (other->load_state != UNIT_LOADED ||
2308 other->type != UNIT_SERVICE)
2311 if (se->state == SERVICE_FAILED)
2312 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2314 if (se->state == SERVICE_DEAD ||
2315 se->state == SERVICE_STOP ||
2316 se->state == SERVICE_STOP_SIGTERM ||
2317 se->state == SERVICE_STOP_SIGKILL ||
2318 se->state == SERVICE_STOP_POST ||
2319 se->state == SERVICE_FINAL_SIGTERM ||
2320 se->state == SERVICE_FINAL_SIGKILL ||
2321 se->state == SERVICE_AUTO_RESTART)
2322 socket_notify_service_dead(s, false);
2324 if (se->state == SERVICE_RUNNING)
2325 socket_set_state(s, SOCKET_RUNNING);
2328 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2329 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2332 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2333 [SOCKET_DEAD] = "dead",
2334 [SOCKET_START_PRE] = "start-pre",
2335 [SOCKET_START_POST] = "start-post",
2336 [SOCKET_LISTENING] = "listening",
2337 [SOCKET_RUNNING] = "running",
2338 [SOCKET_STOP_PRE] = "stop-pre",
2339 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2340 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2341 [SOCKET_STOP_POST] = "stop-post",
2342 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2343 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2344 [SOCKET_FAILED] = "failed"
2347 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2349 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2350 [SOCKET_EXEC_START_PRE] = "StartPre",
2351 [SOCKET_EXEC_START_POST] = "StartPost",
2352 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2353 [SOCKET_EXEC_STOP_POST] = "StopPost"
2356 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2358 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2359 [SOCKET_SUCCESS] = "success",
2360 [SOCKET_FAILURE_RESOURCES] = "resources",
2361 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2362 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2363 [SOCKET_FAILURE_SIGNAL] = "signal",
2364 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2365 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2368 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2370 const UnitVTable socket_vtable = {
2371 .object_size = sizeof(Socket),
2378 .private_section = "Socket",
2379 .exec_context_offset = offsetof(Socket, exec_context),
2380 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2382 .init = socket_init,
2383 .done = socket_done,
2384 .load = socket_load,
2386 .kill = socket_kill,
2388 .coldplug = socket_coldplug,
2390 .dump = socket_dump,
2392 .start = socket_start,
2393 .stop = socket_stop,
2395 .serialize = socket_serialize,
2396 .deserialize_item = socket_deserialize_item,
2397 .distribute_fds = socket_distribute_fds,
2399 .active_state = socket_active_state,
2400 .sub_state_to_string = socket_sub_state_to_string,
2402 .check_gc = socket_check_gc,
2404 .fd_event = socket_fd_event,
2405 .sigchld_event = socket_sigchld_event,
2406 .timer_event = socket_timer_event,
2408 .trigger_notify = socket_trigger_notify,
2410 .reset_failed = socket_reset_failed,
2412 .bus_interface = "org.freedesktop.systemd1.Socket",
2413 .bus_message_handler = bus_socket_message_handler,
2414 .bus_invalidating_properties = bus_socket_invalidating_properties,
2415 .bus_set_property = bus_socket_set_property,
2416 .bus_commit_properties = bus_socket_commit_properties,
2418 .status_message_formats = {
2419 /*.starting_stopping = {
2420 [0] = "Starting socket %s...",
2421 [1] = "Stopping socket %s...",
2423 .finished_start_job = {
2424 [JOB_DONE] = "Listening on %s.",
2425 [JOB_FAILED] = "Failed to listen on %s.",
2426 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2427 [JOB_TIMEOUT] = "Timed out starting %s.",
2429 .finished_stop_job = {
2430 [JOB_DONE] = "Closed %s.",
2431 [JOB_FAILED] = "Failed stopping %s.",
2432 [JOB_TIMEOUT] = "Timed out stopping %s.",